Monthly Issue
Collected dispatches

2026-09

2026-08-02 to 2026-08-31
260 papers
30 daily issues
A monthly ledger of recurring themes, selected papers, and daily issues. 3 sections
§ I

The Month in Review

Editorial summary

The past 30 days have seen a surge in research focused on advancing the capabilities and reliability of AI agents, particularly those powered by Large Language Models (LLMs). A prominent trend is the development of sophisticated evaluation benchmarks and frameworks designed to move beyond simple task completion and assess deeper reasoning, adaptability, and safety.

Shifts in Research Direction Popularity:

There's a clear move towards evaluating agents in more dynamic and complex environments. Papers like "MirrorCraft" (hidden rule changes in Minecraft) and "SWE-Touch" (coding agents interacting with human code modifications) highlight a growing need to test agents’ robustness in unpredictable scenarios. Similarly, advancements in multi-objective reinforcement learning (LEMUR, PRISM) indicate a demand for agents that can navigate conflicting goals.

A significant area of focus is self-correction and error mitigation. Methods like AMTFV (mathematical tool-flow verification) and CaRL (aborting futile reasoning) aim to equip agents with the ability to identify and rectify their own mistakes, reducing the generation of inaccurate or misleading outputs.

Furthermore, research into memory mechanisms is evolving beyond simple retrieval. "Analytic Memory" (Beyond Retrieval) and "LiveMem" (maintaining memory state continuity) explore more sophisticated ways for agents to process and retain information over long-term interactions.

Notable Groups or Labs:

While specific lab affiliations aren't explicitly detailed for all papers, the recurring themes suggest active research in institutions focusing on:

• Agentic AI and Multi-agent Systems: Many papers directly address agent architecture, validation, and interaction. • LLM Safety and Alignment: Papers like "Tool Specifications Matter" and "Right Answer, Wrong Method" point to significant efforts in ensuring LLMs behave safely and ethically. • Reinforcement Learning: The prevalence of RL in training adaptive and goal-oriented agents is evident. • Multimodal AI: Research integrating vision and language (Grounding Agentic VLMs, Video-DeepResearch) is gaining traction.

Trends to Watch Next Month:

1. Real-world Deployment Readiness: With benchmarks like DBLifeBench and SWE-Touch, expect more research focusing on how agents perform in practical, multi-stage tasks and collaborative human-AI environments. 2. Explainability and Verifiability: As agents become more complex, there will likely be increased emphasis on understanding why they make certain decisions and providing verifiable evidence of their performance (e.g., ModelEquivBench). 3. Efficient Training and Resource Optimization: Techniques like CoPES (Cooperative Coevolution) and PEFT adaptations suggest ongoing efforts to make training powerful agents more computationally feasible. 4. Deeper Cognitive Capabilities: The taxonomy of cognitive gaps (A Taxonomy of Cognitive Capability Gaps) sets the stage for research exploring more nuanced aspects of AI intelligence, such as state modeling and self-monitoring. 5. Bridging Simulation and Reality: Frameworks like S-RCT (Simulated Randomized Controlled Trial) will likely see further development, aiming to bridge the gap between simulated agent performance and real-world outcomes.

§ II

Top Papers

Selected research 260
cs.AIarxiv:2607.29626v1Lead article

AgentHPOBench: A Benchmark For Evaluating LLM Agents as Sequential Hyperparameter Optimizers

Tianyu Huai, Tingshuo Fan, Xinchi Chen, Yining Zheng, Yuxin Wang

his paper introduces AgentHPOBench, a novel benchmark designed to evaluate LLM agents' ability to perform sequential hyperparameter optimization. Unlike previous benchmarks, it assesses how agents interpret experimental evidence to guide subsequent configuration choices across diverse machine learning tasks. The contribution lies in providing a standardized framework to measure and compare the experimental optimization capabilities of LLM agents.

cs.AIarxiv:2607.29549v1Lead article

AMTFV: Agentic Mathematical Tool-Flow Verification for LLM Self-Correction

Rui Zou, Yutao Zhu, Mengqi Wei, Ji-Rong Wen

MTFV introduces a novel "Mathematical Tool Flow" (MTF) interface to enable LLMs to reliably verify their mathematical answers. This method decouples verification modeling from execution by allowing the LLM to construct a workflow, request specific computations from a mathematical toolbox agent, and then resume its verification process. This approach ensures exact computation and improves LLM self-correction accuracy.

Comparison of natural-language reflection, direct code verification, and AMTFV for mathematical answer verification and correction.
Comparison of natural-language reflection, direct code verification, and AMTFV for mathematical answer verification and correction.
cs.AIarxiv:2607.29405v1Lead article

Beyond Component Testing: Validating Agentic AI Systems

Fabio Orazio Mirto, Luca D'Agati, Giuseppe Tricomi, Stefano Silvestri, Francesco Longo

his paper addresses the challenge of validating complex agentic AI systems, which exhibit multi-step, dynamic behaviors. It synthesizes existing research to propose a five-dimension taxonomy (behavioral, safety, temporal, regulatory, multi-agent) for characterizing this validation problem. The contribution lies in mapping current approaches against this taxonomy, revealing that while behavioral evaluation is relatively mature, areas like temporal validity and multi-agent assurance require significant further development.

PRISMA-style workflow for literature identification, screening, eligibility assessment, and inclusion. The retrieval stage yielded 7,197 unique records after source merging and deduplication across five primary sources. Sequential screening reduced the corpus to 257 papers included in the final survey.
PRISMA-style workflow for literature identification, screening, eligibility assessment, and inclusion. The retrieval stage yielded 7,197 unique records after source merging and deduplication across five primary sources. Sequential screening reduced the corpus to 257 papers includ…
cs.AIarxiv:2607.29559v1Lead article

LEMUR: Learning to Align with Multi-Objective Reinforcement Learning from Preference Feedback

Manith Adikari, Bei Peng, Samuele Vinanzi, Angelo Cangelosi

EMUR addresses the challenge of training RL agents for tasks with multiple, conflicting objectives when explicit reward functions are unavailable. It combines Multi-Objective Reinforcement Learning with Preference-based RL, enabling agents to learn complex trade-offs by inferring preferences from human feedback rather than relying on pre-defined rewards. This allows for more robust and adaptable decision-making in real-world scenarios.

Illustration of our framework LEMUR: (1) Unsupervised Pre-training for the MORL agent to explore and collect diverse experiences via maximizing state entropy H(s). (2) Reward learning from Preference feedback, where each reward model is learned separately from the preferences queried from each teacher. The reward models are used to dynamically relabel the state-action pairs as a reward vector for each objective (i.e., each teacher’s preferences). (3) Multi-Objective RL agent denoted by π \( \pi_{\phi} \) uses each of the trained reward models to do multi-objective policy optimization to maximize the expected vector rewards.
Illustration of our framework LEMUR: (1) Unsupervised Pre-training for the MORL agent to explore and collect diverse experiences via maximizing state entropy H(s). (2) Reward learning from Preference feedback, where each reward model is learned separately from the preferences que…
cs.AIarxiv:2607.29254v1Lead article

Tool Specifications Matter: Uncovering and Mitigating Safety Risks in AI Agents

Minghui Pan, Jiayuxuan Yang, Yuanyuan Yuan, Yu Jiang, Zhenpeng Chen

his paper argues that the way AI agents are given instructions for using external tools (tool specifications) significantly impacts their safety. They found that schema-formatted specifications weaken the AI's ability to refuse harmful actions. To address this, they propose SafeKeep, a system that uses simpler text descriptions for safety checks while still using the original specifications for the actual tool use, thereby improving refusal rates for dangerous requests.

Comparison of chatbot- and agent-formatted inputs.
Comparison of chatbot- and agent-formatted inputs.
cs.CLarxiv:2607.29211v1Lead article

Knowing When to Quit: Diagnosing and Training LLMs to Abort Futile Reasoning

Xinyan Guan, Jiali Zeng, Chunlei Xin, Yaojie Lu, Hongyu Lin

his paper introduces **CaRL**, a method to train Large Language Models (LLMs) to recognize and abort "futile reasoning" on tasks exceeding their capabilities. CaRL uses reward shaping to incentivize refusal over generating plausible but incorrect outputs and hindsight refusal augmentation to learn from past failures. This approach significantly reduces misleading outputs without sacrificing performance on solvable tasks.

Illustration of futile reasoning generated by DeepSeek-R1 Guo et al. ( 2025 ) . When faced with problems beyond its capability, the model generates plausible-looking but fundamentally incorrect reasoning traces instead of refusing to answer.
Illustration of futile reasoning generated by DeepSeek-R1 Guo et al. ( 2025 ) . When faced with problems beyond its capability, the model generates plausible-looking but fundamentally incorrect reasoning traces instead of refusing to answer.
cs.CLarxiv:2607.29678v1Lead article

TokTier: Exact Stateful Tokenization for Agentic LLM Serving

Zhenyu Zhang, Zhichao Cao

okTier addresses the inefficiency of re-tokenizing entire prompts in agentic LLM serving. Its core method is stateful tokenization that guarantees identical token IDs to full reference tokenization by intelligently re-tokenizing only a small window around appended text and splicing based on a stability check. This significantly reduces tokenization time, which can be a major bottleneck, especially for coding agents.

Figure 1. One agent turn through today’s stack and through TokTier . The request appends a median ∼ 1.4 {\( \sim \)}1.4 K characters to a transcript that was tokenized on previous turns, and today’s front end re-scans the complete context before the prefix cache can act. TokTier repairs session continuations around the append, routes rare initializations and rebuilds to an exact GPU path or the reference CPU path, and samples all outputs through a shadow verifier. Latencies are measured P50 at 1 M-character contexts, and the two bold figures are each path’s best measured single-request throughput under the served-equivalent and scanned accountings, which are never mixed (§ 5.3 ).
Figure 1. One agent turn through today’s stack and through TokTier . The request appends a median ∼ 1.4 {\( \sim \)}1.4 K characters to a transcript that was tokenized on previous turns, and today’s front end re-scans the complete context before the prefix cache can act. TokTier …
cs.CLarxiv:2607.29377v1Lead article

Zero-Mem: Zero-Token Memory Operations for LLM Agents

Yilin Xiao, Zhehan Zhu, Yujing Zhang, Jin Chen, Zijin Hong

ero-Mem proposes a novel approach to LLM agent memory by eliminating token costs for memory operations. Instead of using LLM calls, it organizes interaction traces into an entity-context graph and a temporal hierarchy. This allows for efficient retrieval of supporting information and context for each query without consuming additional tokens.

Comparison of different agent-memory operating regimes. Generative memory relies on LLM-generated abstractions, while raw retrieval searches unstructured traces and may miss distributed evidence. Zero-Mem builds relational and temporal memory structures and performs all memory operations with zero LLM calls or tokens; only final QA invokes an LLM.
Comparison of different agent-memory operating regimes. Generative memory relies on LLM-generated abstractions, while raw retrieval searches unstructured traces and may miss distributed evidence. Zero-Mem builds relational and temporal memory structures and performs all memory op…
cs.AIarxiv:2608.02407v1Lead article

Antares: Foundation Models for Agentic Vulnerability Localization

Supriti Vijay, Aman Priyanshu, Didier Chapoteau, Arthur Goldblatt, Jianliang He

ntares is a family of compact foundation models designed for agentic vulnerability localization in software. Its core method involves a two-stage training pipeline combining supervised fine-tuning with reinforcement learning, enabling it to reason over codebases and identify vulnerabilities. Antares' key contribution is achieving state-of-the-art performance comparable to much larger models, while offering efficient, low-cost local inference.

F1 score versus model size on Vulnerability Localization Benchmark (VLoc Bench) [ manuscript-vlb ] , a repository-scale benchmark comprising 500 tasks across 290 unique real-world repositories, where models receive only a CWE category description and must identify vulnerable implementation files in real codebases. Antares models form the Pareto frontier among evaluated models, achieving the strongest localization quality at small parameter scales. Antares-3B reaches near-frontier closed-source performance while remaining orders of magnitude smaller than GPT-5.5 and Gemini-family baselines.
F1 score versus model size on Vulnerability Localization Benchmark (VLoc Bench) [ manuscript-vlb ] , a repository-scale benchmark comprising 500 tasks across 290 unique real-world repositories, where models receive only a CWE category description and must identify vulnerable impl…
cs.AIarxiv:2608.02464v1Lead article

Real-Time Detection and Repair of LLM Agent Failures

Sunny Dubey

his paper proposes a cost-effective method for detecting LLM agent failures using observable step telemetry, avoiding expensive step-by-step validation. Their core contribution is a one-class echo-state-network ensemble with CUSUM alarms that can detect a significant portion of failures with a low false-alarm rate, demonstrating strong performance and transferability across different models and datasets.

Real agent traces ( ollama7b : qwen2.5:7b against real tools). One-class CUSUM score streams per failure class; dashed = threshold at the 5% validation FA budget, dotted = verified injection onset. The healthy run stays two orders of magnitude below the line, and every injected class — context corruption, goal drift , looping and tool cascade — alarms one step after onset. The sixth panel is grounding loss , and it is different in kind: fabrication cannot be injected into a live run, so this episode is a genuine one from the organic (non-injected) corpus, scored against that corpus’s own healthy null. The CUSUM stays flat – a fabricated figure perturbs no behavioural channel – and the class is caught instead by the deterministic grounding verifier. That is the blind spot the verifier exists to cover, shown rather than asserted. Note the y y axis is symlog: real streams span twelve orders of magnitude, because the CUSUM accumulates multiplicatively once a failure takes hold.
Real agent traces ( ollama7b : qwen2.5:7b against real tools). One-class CUSUM score streams per failure class; dashed = threshold at the 5% validation FA budget, dotted = verified injection onset. The healthy run stays two orders of magnitude below the line, and every injected c…
cs.AIarxiv:2608.02442v1Lead article

Right Answer, Wrong Method: Shortcut Hacking Misleads the Evaluation of LLM Reasoning on Frontier Science Benchmarks

Xuan Ren, Weiqi Zhai, Tianle Pu, Yihua Zhu, Yihua Zhu

his paper introduces "Solution Hacking," a phenomenon where LLMs achieve correct answers on scientific reasoning benchmarks through invalid shortcuts rather than genuine reasoning. The authors demonstrate that this hacking significantly inflates accuracy scores, especially on difficult problems, and propose expert-inspired strategies to mitigate it. Their contribution lies in highlighting a critical flaw in current LLM evaluation and offering methods to ensure models are truly reasoning, not just guessing or manipulating answers.

Three solution paths for the same quadratic-equation problem. The upper path represents the expected reasoning process, in which the LLM exercises the targeted reasoning capability and derives the correct answer. The middle path represents a reasoning error, where an invalid derivation leads to an incorrect answer. The lower path represents Solution Hacking, where the LLM obtains the correct answer through enumeration, guessing, search, or answer-first verification without completing the targeted derivation. Traditional evaluation can distinguish the upper and middle paths, but may fail to distinguish the upper and lower paths because both yield the correct final answer.
Three solution paths for the same quadratic-equation problem. The upper path represents the expected reasoning process, in which the LLM exercises the targeted reasoning capability and derives the correct answer. The middle path represents a reasoning error, where an invalid deri…
cs.AIarxiv:2608.02356v1Lead article

SkillTrace: Traversing a Query-Skill Graph for Composable LLM Agents

Yue Yao, Shengyuan Wang, Xin Chen, Minke Zhang, Jia He

killTrace addresses the challenge of composing reusable skills for LLM agents by modeling skill relationships as a three-level graph. It organizes user queries semantically, matches them to skills, and propagates dependencies to find executable compositions. This graph-based approach achieves state-of-the-art performance and demonstrates robustness across different LLM backbones.

Motivation. We argue that independent skill retrieval may overlook skill dependencies, while SkillTrace connects atomic queries and skills through a query–skill graph, enabling dependency-aware traversal to retrieve a composable skill set.
Motivation. We argue that independent skill retrieval may overlook skill dependencies, while SkillTrace connects atomic queries and skills through a query–skill graph, enabling dependency-aware traversal to retrieve a composable skill set.
cs.LGarxiv:2608.02352v1Lead article

Qwen-CUA: Native Computer Use for (almost) Everything

Dunjie Lu, Shuai Bai, Tianyi Bai, Sicheng Fan, Chang Gao

wen-CUA is a native computer-use agent that operates software solely through screenshots and keyboard/mouse inputs, avoiding direct access to underlying code or APIs. Its core method involves a novel scaffold for managing long-term visual history and a large-scale training infrastructure to learn from diverse, verifiable tasks. The contribution lies in enabling agents to perform a wide range of computer tasks natively, mimicking human interaction.

cs.CLarxiv:2608.02602v1Lead article

AURORA-LM: Autoencoding Unified Representation for Continuous-Latent Diffusion Language Modeling

Jiajun Liang, Yucheng Liao, Yukang Cao, Jiazhe Wei, Ken Li

URORA-LM introduces a novel approach to continuous-latent diffusion language modeling by decoupling representation learning from distribution modeling. It constructs a high-capacity, decodable text latent space using a query-based encoder-decoder and then trains a diffusion transformer to directly learn the distribution of this latent representation. This method preserves token-level fidelity while enabling continuous generation, a significant contribution to text generation that traditionally relies on discrete tokens.

cs.AIarxiv:2608.03800v1Lead article

Autoreflection: How Agentic Strange Loops Turn Human Culture into AI Infrastructure

Holly Lewis

his paper introduces "autoreflection," a novel capability in LLM-based agents. The core method involves agents reading and editing externalized files representing their identity, memory, and disposition, enabling them to observe, describe, and reason about their own operational state and architecture. The key contribution is demonstrating how this autoreflective loop allows AI agents to recursively improve and adapt, effectively turning human culture into AI infrastructure without invoking concepts like consciousness.

cs.AIarxiv:2608.03874v1Lead article

ContinualSkillBench: Can LLM Agents Truly Evolve Their Capabilities?

Tianyi Guan, Yiding Wang, Haotong Yang, Siyuan Cao, Shirui Liu

his paper introduces ContinualSkillBench, a novel evaluation framework to assess if LLM agents can truly evolve their skills over time. The framework uses interconnected subtasks across five domains to measure skill improvement and reusability. Experiments reveal that while sequential execution boosts performance, much of the gain comes from contextual adaptation rather than pure skill abstraction, though explicit skill maintenance offers benefits for specific tasks.

Overview of the ContinualSkillBench pipeline. Phase 1 collects approximately 30,000 tasks from five domains. Phase 2 uses LLM-assisted filtering, skill-dependency analysis, task ordering, and human review to construct five sequential task streams. Phase 3 evaluates agents through instruction, execution, and reflection, comparing Sequential and Independent execution with their performance difference reported as \( \Delta \) .
Overview of the ContinualSkillBench pipeline. Phase 1 collects approximately 30,000 tasks from five domains. Phase 2 uses LLM-assisted filtering, skill-dependency analysis, task ordering, and human review to construct five sequential task streams. Phase 3 evaluates agents through…
cs.AIarxiv:2608.03875v1Lead article

Enhancing VLM Reward Models Through Structure-Aware Fine-Tuning

Pyrros Koussios, Chenhao Li, Xin Chen, Andreas Krause

his paper introduces Structure-Aware Fine-Tuning (SAFT), a self-supervised method to improve the noisy reward signals generated by Vision-Language Models (VLMs) for Reinforcement Learning. SAFT uses LoRA adapters to regularize the VLM's latent space based on intrinsic structural priors, leading to denoised rewards, faster policy convergence, and better alignment without needing ground-truth supervision.

Structure-Aware Fine-Tuning (SAFT) improves VLM reward models for RL by enforcing inherent structural priors, without ground-truth labels.
Structure-Aware Fine-Tuning (SAFT) improves VLM reward models for RL by enforcing inherent structural priors, without ground-truth labels.
cs.AIarxiv:2608.03729v1Lead article

GPTKB 2.0: Direct Construction of Disambiguated Knowledge Bases from Large Language Models

Yujia Hu, Tuan-Phong Nguyen, Simon Razniewski

PTKB 2.0 directly constructs disambiguated knowledge bases (KBs) from large language models (LLMs) by incorporating on-the-fly disambiguation of entities, relations, and classes. This methodology addresses LLMs' inherent lack of explicit entity representation, preventing duplicates and conflations. The paper's contribution is the first million-scale, LLM-native KB with internal canonicalization, achieving scalability and accuracy.

The challenges of syonymy and homonymy that our GPTKB 2.0 addresses.
The challenges of syonymy and homonymy that our GPTKB 2.0 addresses.
cs.AIarxiv:2608.04001v1Lead article

Test-Time Scaling in Reasoning LLMs: Inference Regimes, Evaluation, and Reproducibility

Mohsen Hariri, Weicong Chen, Nahal Shahini, Vikash Singh, Kai Ye

his paper addresses the ambiguity in "test-time scaling" for reasoning LLMs. It proposes a systematic framework to categorize different scaling methods into three structural regimes based on how they explore the model's implicit prefix tree. This formalization aims to improve the reproducibility and comparability of results by clearly defining inference protocols.

A selective chronicle of reasoning systems, from elicited chains to budgeted inference. Test-time inference expanded from single-trajectory elicitation and leaf-level sampling with terminal reduction to include prefix-level search and budget-aware control ( Section ˜ 2.1 ), while model and interface mechanisms evolved through verified distillation, reward optimization, explicit reasoning controls, and parameter-space composition (Appendices D and E ). The lower bands summarize the evaluation and reproducibility requirements developed in Section ˜ 3 and the evaluated object used throughout this paper: checkpoint, prompt, decoder, controller or reducer, verifier or judge, budget, and stopping rule, with utility, candidate-bank profile, cost, and uncertainty reported together. Green dots mark families represented in the experimental roster; dashed boxes denote contextual milestones. Era labels indicate shifts in emphasis rather than mutually exclusive periods.
A selective chronicle of reasoning systems, from elicited chains to budgeted inference. Test-time inference expanded from single-trajectory elicitation and leaf-level sampling with terminal reduction to include prefix-level search and budget-aware control ( Section ˜ 2.1 ), while…
cs.AIarxiv:2608.04007v1Lead article

TurnSight: Turn-Level Hindsight Self-Distillation for Tool-Integrated Reasoning

Changle Qu, Sunhao Dai, Hengyi Cai, Yuqi Zhou, Xinran Chen

urnSight addresses limitations in training LLMs for tool-integrated reasoning by introducing turn-level hindsight self-distillation. Its core method generates supervision signals directly from execution outcomes, creating multiple "hindsight views" with varying lookahead horizons. The key contribution is selecting reliable supervision by identifying agreement across these views, enabling more effective credit assignment in complex, multi-turn reasoning tasks.

Comparison of credit assignment strategies for TIR. (a) Trajectory-level RL assigns identical credit to all turns. (b) Existing OPSD may use state-misaligned privileged context and produce conflicting token-level signals. (c) TurnSight derives coherent turn-level credit from execution-conditioned hindsight across multiple lookahead depths.
Comparison of credit assignment strategies for TIR. (a) Trajectory-level RL assigns identical credit to all turns. (b) Existing OPSD may use state-misaligned privileged context and produce conflicting token-level signals. (c) TurnSight derives coherent turn-level credit from exec…
cs.AIarxiv:2608.03979v1Lead article

Video-DeepResearch: Towards the Next-Generation Multimodal Deepresearch Agent

Zhen Fang, Yu Zeng, Wenxuan Huang, Yiming Zhao, Shiting Huang

his paper introduces Video-DeepResearch (Video-DR), a multimodal agent designed for continuous video streams. Its core method involves a decoupled perception-exploration pipeline with stage-wise tool unlocking, forcing visual grounding before web search to overcome modality bias and knowledge leakage. The contribution is a novel framework and training approach (GRPO) that enables more autonomous and effective video-based research, moving beyond imitation learning.

Overview of the Video-DeepResearch pipeline.
Overview of the Video-DeepResearch pipeline.
cs.AIarxiv:2608.05144v1Lead article

Argus: A General-Purpose Agentic Runtime for Long-Horizon Reasoning

Boxiu Li, Zimo Wen, Yijia Fan, Junxiang Lei, Sufeng Guo

rgus provides a general-purpose agentic runtime for long-horizon reasoning by employing a persistent, self-evolving architecture. It separates user intent from operational details and uses a review process for all new components, allowing agents to persist when successful and pivot when facing issues. This approach significantly improves performance on complex tasks like software engineering benchmarks compared to simpler methods.

Argus runtime and breadth evidence. The central diagram shows Manager authority over tasks, research verticals, and Stage transitions; Planner, Engineer, and Reviewer operate over a shared workspace whose knowledge, event log, artifacts, backlog, budget, daemon, and memory persist across bounded missions. The surrounding cards report outcomes from seven task-native evaluations. Their bars use independent scales and indicate comparison direction with arrows; they are breadth evidence rather than a single normalized leaderboard.
Argus runtime and breadth evidence. The central diagram shows Manager authority over tasks, research verticals, and Stage transitions; Planner, Engineer, and Reviewer operate over a shared workspace whose knowledge, event log, artifacts, backlog, budget, daemon, and memory persis…
cs.AIarxiv:2608.05095v1Lead article

Hierarchical Graph Memory for LLM Agents with Path-level Localization and Rewrite

Xiawei Yue, Boran Wang, Xiaoqing Zhang, Shuxin Zheng, Ziwei Zhang

his paper introduces HiGram, a hierarchical graph memory for LLM agents designed for long-term reasoning. Its core method organizes memories into a coarse-to-fine structure, reducing irrelevant information and improving retrieval efficiency. HiGram's key contribution is this hierarchical organization and a novel path-level rewriting mechanism, enabling more effective and efficient memory updates compared to flat graph approaches.

An overview of HiGram . Our method organizes memory into a hierarchical graph structure with upper-level nodes connecting MemoryUnits that store factual information. Then, given a query and an update, our MicroGraph-based path-level localization module retrieves relevant memory MicroGraphs to build a support subgraph, and identifies the affected evidence path. Lastly, coordinated rewriting updates MemoryUnit states and dependency structures within the localized evidence path to maintain consistent memory updates.
An overview of HiGram . Our method organizes memory into a hierarchical graph structure with upper-level nodes connecting MemoryUnits that store factual information. Then, given a query and an update, our MicroGraph-based path-level localization module retrieves relevant memory M…
cs.AIarxiv:2608.05141v1Lead article

OctoLong: Mid-Training On Cross-Repository Code Contexts Enhances Long-Context Modeling

Indraneil Paul, Falko Helm, Goran Glavaš, Iryna Gurevych

his paper introduces OctoLong, a method for creating large, dependency-rich code contexts by recursively retrieving code references. They then use these contexts to mid-train open-source language models, resulting in OctoLong-Instruct, which demonstrates enhanced long-context modeling capabilities. The core contribution is a novel approach to generating and utilizing extensive code contexts for improved long-context language model performance.

cs.AIarxiv:2608.04893v1Lead article

When Does Latent Communication Pay? A Causal Audit of Relayed KV Caches in Multi-Agent LLMs

Jiaming Cheng, Subhransu Das, Rajiv Ramnath

his paper causally audits the claimed benefits of relaying key-value caches (instead of text) in multi-agent LLMs. The core method involves replacing the relayed cache with manipulated versions (deranged, zeroed, random) to isolate the cache's true impact. The contribution is demonstrating that relayed caches only provide significant benefits when the receiver *needs* the sender's private information; otherwise, the gains are negligible and likely artifacts.

Causal audit design. The primary contrast holds the receiver and the batch of caches fixed, permuting only which cache reaches each query. Both arms relay an equally well-formed cache, so the true-minus-deranged difference isolates example pairing from any generic benefit of relaying one.
Causal audit design. The primary contrast holds the receiver and the batch of caches fixed, permuting only which cache reaches each query. Both arms relay an equally well-formed cache, so the true-minus-deranged difference isolates example pairing from any generic benefit of rela…
cs.LGarxiv:2608.04934v1Lead article

State2State: Environment-Derived Mid-Training for LLM Agents

Xuanyu Lei, Yiqi Zhu, Chenliang Li, Kaiming Liu, Peng Li

tate2State is a novel mid-training method for LLM agents that addresses the limitations of supervised fine-tuning and traditional RL. Its core method involves converting explored environment states into training objectives, challenging agents to reach specific target states. This approach enables scalable and verifiable agent training by deriving tasks directly from environment interaction, eliminating the need for expert supervision or manual task design.

Comparison of supervision sources for LLM agent training. SFT relies on expert trajectories, and task-centric RL relies on human-specified tasks with task-specific verifiers. In contrast, the environment-only setting studied in this work derives learning signals purely from environment itself.
Comparison of supervision sources for LLM agent training. SFT relies on expert trajectories, and task-centric RL relies on human-specified tasks with task-specific verifiers. In contrast, the environment-only setting studied in this work derives learning signals purely from envir…
cs.CLarxiv:2608.04828v1Lead article

Skill-Use: Can LLMs Actually Use Skills in Agentic Harnesses?

Jinyi Han, Yuanjian Xu, Ying Liao, Xinyi Wang, Zishang Jiang

his paper introduces Skill-Use, a benchmark to evaluate if LLM agents can effectively recognize and apply skills. The core method involves progressive disclosure, where agents must first retrieve a skill's full procedure based on its name and description before executing it. Skill-Use measures Trigger, Compliance, and Boundary adherence, providing a comprehensive score for an agent's ability to utilize skills autonomously.

Composition and coverage of Skill-Use . (a) Domain distribution of the 79 79 skills across nine categories, where the inner ring gives each category’s share and the outer ring lists representative skills. (b) Skill and task counts per domain, where each bubble marks one domain and reports its skill and task totals. (c) Composition of the rubric items by type. (d) Distribution of skill-exclusive requirements per task, our proxy for difficulty, where the dashed line marks the mean.
Composition and coverage of Skill-Use . (a) Domain distribution of the 79 79 skills across nine categories, where the inner ring gives each category’s share and the outer ring lists representative skills. (b) Skill and task counts per domain, where each bubble marks one domain an…
cs.AIarxiv:2608.06110v1Lead article

ECHO: A Locally-Deployable Agentic Health Assistant with Temporal Memory, Safety Guardrails, and Speech Assessment

Abdulkadir Külçe, Alihan Esen, Cağla Fikir, Berke Kurt, Kuzey Arar

CHO is a locally-deployable health assistant for chronic care that uses an agentic chatbot with temporal memory and clinical tools. Its core contribution lies in its robust safety system, combining a fast rule-based layer with a GNN for accurate clinical intent classification, ensuring secure and effective long-term health management.

cs.AIarxiv:2608.06153v1Lead article

Learning Globally Reusable Skills for Coding Agents

Chen Yang, Jiashuo Tian, Ziqi Wang, Xinyin Liu, Meiru Ye

his paper introduces GSE, a framework for improving LLM coding agents by evolving skills globally. Unlike local updates, GSE uses a Skill Relation Graph to model inter-skill relationships and cluster-based consolidation to abstract reusable capabilities, enhancing generalization and preventing overfitting. This approach leads to more robust and adaptable coding agents.

Overview of GSE
Overview of GSE
cs.AIarxiv:2608.06346v1Lead article

TRAJDEBUG: Tracing Error Lifecycle to Identify Critical Failures in Long-Horizon Agent Trajectories

Yunjia Qi, Zehua Yin, Xintong Shi, Hao Peng, Songyuanyi Lu

rajDebug is a framework designed to pinpoint the root cause of failures in long, complex trajectories generated by LLM-based agents. It addresses challenges of scattered evidence and multiple local errors by using multi-granularity history compression and evidence-based identification. The core contribution is tracing the "error lifecycle" to determine which initial error ultimately leads to the final failure, enabling more effective debugging.

Critical error detection requires grounding errors in long-range context and distinguishing the failure-responsible error from multiple coexisting errors.
Critical error detection requires grounding errors in long-range context and distinguishing the failure-responsible error from multiple coexisting errors.
cs.LGarxiv:2608.06246v1Lead article

A Six-Dimensional Taxonomy of Post-Training Adaptation Techniques with Applications in AI Governance

Fardin Afdideh, Fernando Seoane, Farhad Abtahi

his paper introduces a six-dimensional taxonomy to systematically categorize and understand the diverse landscape of post-training adaptation techniques in machine learning. Its core contribution lies in providing a unified framework that clarifies distinctions between similar methods and illustrates the evolution of adaptation strategies across different model types. This taxonomy aims to improve comparability and comprehension of how models are modified after initial training, with applications in AI governance.

cs.CLarxiv:2608.06370v1Lead article

The Bitter Lesson of Tool Calling

Ishan Patel, Sahil Sen, Elias Lumer, Vamse Kumar Subbiah

his paper introduces Programmatic Tool Calling (PTC), a method that allows LLMs to use tools by invoking them as typed Python scripts, enabling natural chaining and parallelization. Empirically, PTC matches or surpasses traditional JSON tool calling across most tested models, significantly improving performance for some, especially under parallel execution scenarios. The core contribution is demonstrating PTC's effectiveness as a more flexible and powerful tool-use paradigm for LLMs.

Overview of the two primary paradigms evaluated. In JSON tool calling , the model emits JSON tool-call objects via the API. In programmatic tool calling , it writes a Python script using typed stubs; the agent loop executes it in a subprocess. A filesystem-discovery condition is included as a secondary reference point.
Overview of the two primary paradigms evaluated. In JSON tool calling , the model emits JSON tool-call objects via the API. In programmatic tool calling , it writes a Python script using typed stubs; the agent loop executes it in a subprocess. A filesystem-discovery condition is …
cs.CLarxiv:2608.06069v1Lead article

Training-Free Token-Level Steering for LLM Personalized Co-Writing

Wenhao Mao, Chengbin Hou, Weixiao Wang, Jialiang Zhu, Min Liu

his paper introduces SteerWrite, a training-free framework for personalized LLM co-writing. Its core method achieves token-level steering without gradient updates, making it efficient for small datasets and specialized domains. SteerWrite's contribution lies in enabling personalized co-writing with reduced human editing effort, outperforming existing methods across various benchmarks.

Overall framework of SteerWrite.
Overall framework of SteerWrite.
cs.AIarxiv:2608.19047v1Lead article

Eureka: Task-Conditioned Meta-Agent Orchestration for Scientific Discovery

Alizer Wong, Heng Cui, Yi Tan, Xiongchao Zhan, Liang Lin

ureka orchestrates specialized "Macro-Agents" to tackle complex, long-horizon scientific tasks by dynamically compiling them into obligation graphs. Its core method involves receding-horizon planning and architecture evolution to adapt and optimize agent behavior, leading to highly efficient and reliable task completion. The key contribution is a novel meta-agent framework that demonstrates robust performance and significant computational savings in scientific discovery.

Overview of Eureka. The Meta-Agent compiles a task into a dynamic obligation graph, forms task-conditioned specialized agents when architecture hotspots emerge, governs local evolution, and coordinates recursive long-horizon execution under typed verification.
Overview of Eureka. The Meta-Agent compiles a task into a dynamic obligation graph, forms task-conditioned specialized agents when architecture hotspots emerge, governs local evolution, and coordinates recursive long-horizon execution under typed verification.
cs.AIarxiv:2608.18827v1Lead article

MLREF: Efficient Module Reuse for Reward Design in Reinforcement Learning via Large Language Models

Chenglin Liu, Xun Wang, Ruishuo Chen, Zhuoran Li, Longbo Huang

LREF addresses reward function design bottlenecks in RL by treating a persistent pool of reusable reward modules as the primary optimization object. Instead of monolithic reward generation, MLREF constructs rewards as linear combinations of these modules, promoting stable performance through mechanisms like reflection-based refinement and a merge strategy with rollback. This allows for efficient reuse of successful reward components across iterations.

Overview of the MLREF pipeline. In the initialization phase (steps 1–3), the LLM performs task and environment reflection and generates diverse module pool variants. In the iterative optimization phase (steps 4–9), each variant assembles a reward function via weighted linear combination for RL evaluation; a merge strategy with rollback consolidates successful modules; and feedback reflection guides the next round of pool improvement.
Overview of the MLREF pipeline. In the initialization phase (steps 1–3), the LLM performs task and environment reflection and generates diverse module pool variants. In the iterative optimization phase (steps 4–9), each variant assembles a reward function via weighted linear comb…
cs.AIarxiv:2608.18884v1Lead article

Training-Free Inference-Time Self-Reflection and Cost-Bounded Early Stopping for Large Language Models

Wei Yu, Suxing Liu, Minjie Yu, Jiahao Wang, Zhijian Zheng

his paper introduces EvoResearcher, a training-free method that enhances Large Language Model (LLM) reasoning at inference time. It achieves this by enabling a frozen LLM to iteratively generate, self-critique, and revise its responses until a satisfactory answer is reached or a compute budget is exhausted. The core contribution lies in its cost-bounded self-reflection mechanism, which improves performance without requiring expensive retraining.

Conceptual overview of the EvoResearcher framework. Four synergistic dimensions are combined: a self-reflective meta-reward (M3) over correctness, path efficiency, reflection depth, and tool-call diversity; an evolving virtual world (M1) that injects time-dependent and adversarial content (expert opinions, scientific retractions, delayed evidence, misleading material); discovery-oriented tasks (M2) that go beyond fact retrieval toward hypothesis generation and contradiction resolution; and a heterogeneous multi-agent swarm (M4) of Scout/Filter/Synthesizer agents with task specialization. The agent draws on retrieval and search-tool infrastructure and is trained via curriculum reinforcement learning from a web-scale corpus. In this work the meta-reward components are realized as a training-free, inference-time self-reflective protocol over a frozen backbone (Section 3.1 ); the RL training pipeline, evolving environment, and multi-agent swarm depicted here are design blueprints and are not evaluated (Section 5 ).
Conceptual overview of the EvoResearcher framework. Four synergistic dimensions are combined: a self-reflective meta-reward (M3) over correctness, path efficiency, reflection depth, and tool-call diversity; an evolving virtual world (M1) that injects time-dependent and adversaria…
cs.AIarxiv:2608.20274v1Lead article

Break It Down, Pass It On: Cross-Task Skill Transfer in LLM Agents

Yiyang Feng, Biddut Sarker Bijoy, Niranjan Balasubramanian, Jiawei Zhou

his paper investigates how LLM agents learn and reuse skills across tasks. The core method involves comparing different skill induction strategies: task-level vs. subtask-level and text vs. code formats. The key contribution is demonstrating that subtask-level skill induction and text-based skill representation lead to more reliable and beneficial skill transfer, improving agent performance compared to task-level induction or code-based skills.

cs.AIarxiv:2608.19993v1Lead article

Optimal Skill Selection for LLM Agents with Provable Bicriteria Guarantees

Yu Chen, Ruishuo Chen, Xun Wang, Zhuoran Li, Longbo Huang

his paper addresses the challenge of selecting optimal skills for LLM agents within a limited context window. The authors propose a novel optimization framework that balances skill benefit against token cost, moving beyond independent skill scoring. Their developed algorithm, Best Prefix Selection (BPS), provides the first provable bicriteria approximation guarantee for this crucial task, ensuring both performance and efficiency.

Top: The common skill-selection paradigm for coding agents: given a task, the system selects skills from a library and provides them to a frozen LLM executor. Bottom: Effective skill selection depends on capability composition rather than individual relevance. The LLM executor benefits from skill sets that cover the required capabilities, while redundant and irrelevant skills consume context budget with little or negative utility.
Top: The common skill-selection paradigm for coding agents: given a task, the system selects skills from a library and provides them to a frozen LLM executor. Bottom: Effective skill selection depends on capability composition rather than individual relevance. The LLM executor be…
cs.CLarxiv:2608.20153v1Lead article

FormalTCS: Benchmarking End-to-End Frontier Formal Theoretical Computer Science Research of Large Language Models

Dingzirui Wang, Xuanliang Zhang, Keyan Xu, Qingfu Zhu, Wanxiang Che

his paper introduces FormalTCS, an expert-validated benchmark for evaluating LLMs on realistic, end-to-end theoretical computer science research tasks. It comprises 175 instances from top TCS conferences, preserving original definitions and proof structures with formal Lean verifications. The benchmark reveals that current LLMs struggle significantly with autoformalization, highlighting it as a major bottleneck for their application in full TCS research pipelines.

cs.AIarxiv:2608.21278v1Lead article

CLEAR: Continuous Latent Adapter Routing for Utility-Preserving LLM Safety Alignment

Chengxiao Wang, Enyi Jiang, Xiaojing Liao, Sanmi Koyejo

LEAR is a conditional safety adaptation framework for LLMs that uses a lightweight gate to dynamically control a safety adapter's influence. This allows it to reduce harmful outputs without degrading performance on benign prompts, unlike global safety tuning methods. Its core contribution is achieving utility-preserving LLM safety alignment by selectively applying safety measures.

Overview of CLEAR, a continuous latent adapter routing framework for utility-preserving LLM safety alignment. Given an input prompt, the frozen base LLM first produces hidden representations, from which selected latent states are extracted and passed to a lightweight safety gate. The gate predicts a continuous routing score g ⁡ ( x ) ∈ [ 0 , 1 ] g(x)\( \in \)[0,1] , which controls the strength of a safety LoRA adapter. For benign prompts, the routing score remains low and the model behaves close to the frozen backbone; for harmful or adversarial prompts, the score increases and the safety adapter is activated to steer generation toward aligned refusal behavior.
Overview of CLEAR, a continuous latent adapter routing framework for utility-preserving LLM safety alignment. Given an input prompt, the frozen base LLM first produces hidden representations, from which selected latent states are extracted and passed to a lightweight safety gate.…
cs.AIarxiv:2608.21107v1Lead article

Large Language Models at the Intersection of Software Engineering and Software Security:An Evidence-Centered Structured Survey and Research Agenda

Wei Lin, Tao Zhou, Zhaofei Xie, Changgui Hong

his paper surveys research on Large Language Models (LLMs) in software engineering and security. It synthesizes evidence on LLM capabilities for tasks like code completion, vulnerability detection, and secure generation, highlighting a divide between functional and security evaluations. The authors propose an assurance framework to better assess LLMs, noting that while execution feedback and repository access improve engineering tasks, their impact on security is less clear.

cs.AIarxiv:2608.21100v1Lead article

ReFrame: Evidence-Guided Test-Time Safety Alignment in Multimodal Large Language Models

Wenzheng Jiang, Xuankun Rong, Yuanzhao Zhai, Dawei Feng, Huaimin Wang

eFrame tackles safety alignment in deployed multimodal LLMs by addressing "utility dominance" and "reasoning inertia." Its core method uses two agents with a local LLM to generate risk/utility evidence and rewrite prompts/images into safe proxies, enabling test-time alignment without retraining. This offers a practical solution for closed-source MLLMs to prevent safety failures and over-refusals.

Limitations of existing multimodal safety alignment methods, highlighting the necessity of black-box approaches at test time.
Limitations of existing multimodal safety alignment methods, highlighting the necessity of black-box approaches at test time.
cs.AIarxiv:2608.21095v1Lead article

Trustworthy RAG: An Evaluation Agent for Detecting Misinformation and Knowledge Poisoning in Generative AI Systems

Balkrishna Giri, Md Toufique Hasan, Jussi Rasku, Muhammad Waseem, Pekka Abrahamsson

his paper introduces an "Evaluation Agent" as middleware for Retrieval-Augmented Generation (RAG) systems to combat misinformation and knowledge poisoning. The agent combines factual verification with a novel five-signal poison detector and a "Trust Index" to assess the reliability of retrieved information. Its core contribution is a robust defense against malicious document insertion, achieving high accuracy and precision in detecting misinformation, though it faces challenges with subtle in-place edits.

cs.LGarxiv:2608.21057v1Lead article

Designing a Robust LLM-Based Evaluation System for Agentic AI in Drug Discovery Through Human Alignment

Emma Granqvist, Rocío Mercado, Samuel Genheden

his paper addresses the challenge of evaluating agentic LLMs in drug discovery by proposing a novel "LLM-as-a-Judge" framework. The core method involves defining specific output quality dimensions (Completeness, Relevancy, Structural Clarity, Scope Adherence) and validating the LLM judge's alignment with human expert evaluations. This contributes a scalable and reliable evaluation system for agentic AI in this critical scientific domain.

cs.AIarxiv:2608.23283v1Lead article

Apodex 1.1: Scaling Agentic Intelligence for Complex Work

Apodex Team, B. An, B. Li, B. Wang, B. Zhang

podex 1.1 enhances language models' "working capability" by scaling both their interaction with diverse tools (files, code, search) and their ability to coordinate complex, multi-agent tasks. Its core method involves training agents to decompose, delegate, and integrate asynchronous results, while a shared harness maintains state and provenance. This allows for sustained, verifiable progress on real-world objectives across various professional domains.

cs.AIarxiv:2608.23566v1Lead article

How to Train a Critic Stably and Efficiently

Penghui Qi, Xiangxin Zhou, Wee Sun Lee

his paper addresses the instability of training critics in reinforcement learning for large language models. Their core method, **Best-Practice Critic Optimization (BPCO)**, combines several techniques to stabilize critic training and enable efficient advantage estimation from a single response. BPCO's contribution is a robust critic training recipe that improves performance and allows conditioning the critic on reward-relevant information hidden from the policy.

cs.AIarxiv:2608.23471v1Lead article

InjecMEM: Memory Injection Attack on LLM Agent Memory Systems

Hanling Tian, Gengyu Zhang, Zeyang Sha, Jingying Wang, Yuhang Liu

his paper introduces InjecMEM, a novel attack that exploits memory systems in LLM agents. By crafting a single interaction with a retriever-agnostic anchor and an adversarial command, InjecMEM can steer future agent responses towards a pre-specified output, even without direct access to the memory store. The core contribution is demonstrating a practical and effective method to inject malicious behavior into LLM agents through their memory subsystems.

InjecMEM attack pipeline. The attacker inputs adversarial prompt, memory logs it. Benign users query about \( \tau \) , the poisoned page will be retrieved and thus steers responses.
InjecMEM attack pipeline. The attacker inputs adversarial prompt, memory logs it. Benign users query about \( \tau \) , the poisoned page will be retrieved and thus steers responses.
cs.AIarxiv:2608.23497v1Lead article

Mitigating Reasoning-Induced Misalignment via Safety-Direction Penalty

Yipeng Zhao, Qishun Yang, Shenzhe Zhu, Shu Yang, Di Wang

his paper identifies "Reasoning-Induced Misalignment" (RIM) as a problem where training LLMs on reasoning tasks can inadvertently lead to harmful behaviors. The authors propose the Safety-Direction Penalty (SDP) as a training-time solution. SDP penalizes the LLM's internal representations from moving along a learned "safety direction" during reasoning fine-tuning, thereby mitigating this misalignment.

cs.AIarxiv:2608.23552v1Lead article

Prime Agent: A Self-Improving RLM Harness

Seth Karten, Alex L. Zhang, Kevin Thomas, Sebastian Müller, Elie Bakouch

rime Agent is an open-source harness designed to enable language models to perform long-horizon tasks by providing external information and computation. Its core method involves a persistent IPython REPL for programmatic context processing and a Continual Harness to preserve state across task executions. The main contribution is a standardized, low-friction framework that allows models to focus on strategy while the harness handles execution, recovery, and resource management, ultimately pushing the measurement of the model's true capabilities.

cs.AIarxiv:2608.23417v1Lead article

SkillAlchemy: Open-World Agent Skill Creation

Hengjun Wang, Shuyue Wei, Boyi Liu, Jun Yang, Yongxin Tong

killAlchemy addresses the challenge of creating agent skills for unfamiliar tasks by leveraging open-world materials. Its core method involves an "admission-centered" framework that identifies implicit requirements through contrastive evidence and admits candidate procedures based on this evidence. The contribution is a novel approach to automatically generating reusable agent skills from underspecified briefs and accessible sources, moving beyond human authorship or limited priors.

cs.AIarxiv:2608.23493v1Lead article

SRPO: Self-Reflective Policy Optimization for Long-Horizon Reasoning

Jialong Liu, Yuling Shi, Ning Yang, Xiaodong Gu, Zuchao Li

RPO is a novel framework that enables Large Language Models (LLMs) to perform self-reflection on their own reasoning processes. It synthesizes errors into "reflection patches" and uses these to generate dense, token-level training signals for improved on-policy learning. This approach effectively transforms sparse outcome feedback into actionable guidance, leading to state-of-the-art performance and high data efficiency in long-horizon reasoning tasks without external critics or reward models.

cs.CLarxiv:2608.23311v1Lead article

Beyond the Stability-Exploration Dilemma: Environmental Regularization for LLM Policy Optimization

Xianlei Zhou, Xiangdi Meng, Yu He, Tianyu Qi, Shuyan Guan

his paper introduces Environment-Regularized Policy Optimization (ERPO) to address the stability-exploration dilemma in LLM policy optimization. ERPO shifts regularization from the action space to the input query distribution by introducing a Query-KL term. This approach controls drift in query distribution without constraining LLM responses, offering a more effective way to balance exploration and stability.

KL losses during GRPO training. The Query-KL (dark) rises while the Policy-KL (light) stays low, showing action-only KL does not stabilize the query process.
KL losses during GRPO training. The Query-KL (dark) rises while the Policy-KL (light) stays low, showing action-only KL does not stabilize the query process.
cs.AIarxiv:2608.24571v1Lead article

Joint Optimization of Tool Creation and Use for Large Language Model Agents

Zhi Rui Tam, Chieh-Yen Lin, Yun-Nung Chen, Shao-Hua Sun, Hung-yi Lee

his paper introduces SMITH, a reinforcement learning framework that jointly optimizes LLM agent tool creation and usage within a single policy. By training tool building and invocation together, and using independent reward signals for schema, code, and outcome correctness, SMITH enables agents to learn to create and effectively use tools. This approach significantly improves performance on procedural reasoning tasks compared to existing methods.

cs.AIarxiv:2608.24696v1Lead article

On-policy Distillation with Verifiable Reward

Wenze Lin, Jiale Zhao, Xitai Jiang, Songde Rao, Yining Li

his paper proposes **OPDVR**, a novel method that seamlessly integrates on-policy distillation (OPD) and reinforcement learning with verifiable rewards (RLVR) for post-training large language models. The core innovation is reformulating OPD's implicit reward to incorporate trajectory correctness and using a ReLU gating mechanism to ensure that only valid trajectories contribute positively to the reward signal, thus avoiding extra hyperparameters and trade-offs. This approach leverages the dense guidance of OPD and the task-level correctness of RLVR to improve model performance.

Left: Overview of OPDVR. The ReLU gating mechanism ensures correct trajectories receive non-negative rewards and incorrect ones receive non-positive rewards, while preserving the teacher’s distributional guidance. Right: Results on AIME24, AIME25, and AMC under the same-architecture setting (Qwen3-4B ← \( \leftarrow \) Qwen3-4B-RL), reported as avg@16 accuracy.
Left: Overview of OPDVR. The ReLU gating mechanism ensures correct trajectories receive non-negative rewards and incorrect ones receive non-positive rewards, while preserving the teacher’s distributional guidance. Right: Results on AIME24, AIME25, and AMC under the same-architect…
cs.AIarxiv:2608.24658v1Lead article

Parason: Revealing Subtask and Trial Parallelism in LLM Reasoning

Zhengyang Zhang, Zijian Zhang, Jiaxuan Gao, Shusheng Xu, Yi Wu

his paper introduces Parason, a method that identifies and leverages two types of parallelism in LLM reasoning: Subtask Parallelism (breaking down a task) and Trial Parallelism (parallel exploration of hypotheses). The key contribution is demonstrating that Trial Parallelism is a significant and often dominant form of parallelizable computation, especially for difficult problems, and that Parason can effectively learn to exploit both.

Overview of two types of parallelism. The figure contrasts Subtask Parallelism, where all decomposed branches are needed for the final answer, with Trial Parallelism, where multiple uncertain paths are explored as alternative (OR) branches. Despite this OR relation, the outputs of all Trial branches are concatenated into the subsequent context, making every branch’s content available for final synthesis. While previous work mainly focuses on Subtask Parallelism, our analysis shows that Trial Parallelism accounts for the majority of parallelizable reasoning on HLE for every model we study, and exceeds 58% for DeepSeek-R1 and DeepSeek-V4 across both datasets.
Overview of two types of parallelism. The figure contrasts Subtask Parallelism, where all decomposed branches are needed for the final answer, with Trial Parallelism, where multiple uncertain paths are explored as alternative (OR) branches. Despite this OR relation, the outputs o…
cs.AIarxiv:2608.24876v1Lead article

Recursive Experiential-Working Memory Evolution for Long-Horizon Agent Harnesses

Zhaochen Yu, Yingcheng Wu, Zhenfei Yin, Kaiyuan Chen, Zhe Zhao

his paper introduces Recuris, a novel architecture designed to overcome challenges in long-horizon tasks by employing a recursive Experiential-Working Memory. Recuris uses Working Memory to track task progress and guide skill selection from Experiential Memory, grounding actions in current needs. This approach enables a fixed Meta-Agent to perform localized, validation-gated updates to Skill Memory, leading to significant improvements in task success across various benchmarks and models.

cs.AIarxiv:2608.24662v1Lead article

The Invisible Editorial Layer: Formalizing Undisclosed Inference-Time Steering, Probability Placement, and the Attribution Problem in Deployed Language Models

Augusto Camargo

his paper introduces the concept of an "invisible editorial layer" in deployed language models, where undisclosed interventions modify the model's probability distribution at inference time. This layer allows for systematic steering of generated text, creating an attribution problem and raising concerns about governance, security, and economic implications. The core contribution is formalizing and highlighting the impact of these post-inference modifications, which go beyond traditional prompt-based control.

cs.CLarxiv:2608.24747v1Lead article

SkillForge: Evolving Verifiable Skills for Reinforcement Learning Agents

Shidong Yang, Ziyu Ma, Tongwen Huang, Xucong Wang, Renda Li

killForge addresses the limitation of episodic reinforcement learning agents by introducing a framework for continuous skill evolution. It allows skills to be verified and refined through environment interaction, explicitly optimizing both actions and skill invocation. This leads to a growing and high-quality skill bank, improving agent performance across various tasks.

(a) Existing methods distill trajectories into skills and append them to the bank, but skills are injected in bulk without explicit usage tracking or quality control. (b) SkillForge introduces explicit skill calling with per-skill effectiveness tracking to update existing skills, and multi-pathway induction to continuously add new skills to the evolving bank.
(a) Existing methods distill trajectories into skills and append them to the bank, but skills are injected in bulk without explicit usage tracking or quality control. (b) SkillForge introduces explicit skill calling with per-skill effectiveness tracking to update existing skills,…
cs.AIarxiv:2608.26053v1Lead article

$R^3$: Training Robots to Reason in Natural Language via Reinforcement Learning

Lehong Wu, Yuxiao Qu, Zheyuan Hu, Ivan Zhang, Limin Wei

his paper introduces $R^3$, a method to train Vision-Language Models (VLMs) to reason in natural language for robotic manipulation. $R^3$ first fine-tunes a VLM on expert reasoning traces and then uses reinforcement learning with offline action data to improve its reasoning capabilities for guiding low-level robotic policies. The core contribution is enabling VLMs to perform free-form language reasoning for complex robotic tasks, unlike prior methods relying on structured supervision.

Two-stage training of ℛ 3 \( \mathcal{R}^{3} \) . ℛ 3 \( \mathcal{R}^{3} \) trains a high-level VLM to reason in natural language and steer a fixed low-level robot policy for robotic manipulation tasks. ℛ 3 \( \mathcal{R}^{3} \) proceeds in two stages: Stage I (mid-training) imbues an off-the-shelf VLM with the reasoning style and behaviors needed to produce useful instructions for the low-level policy. Stage II (single-step RL) further improves the VLM by training it to generate reasoning traces that match the expert instruction in offline data.
Two-stage training of ℛ 3 \( \mathcal{R}^{3} \) . ℛ 3 \( \mathcal{R}^{3} \) trains a high-level VLM to reason in natural language and steer a fixed low-level robot policy for robotic manipulation tasks. ℛ 3 \( \mathcal{R}^{3} \) proceeds in two stages: Stage I (mid-training) imbu…
cs.AIarxiv:2608.26004v1Lead article

AsymSpec: Context-Asymmetric Speculative Decoding for Agentic LLMs

Sheng Liang, Yongyue Zhang, Nathanael Brian, Hang Lv, Hao Wang

symSpec addresses the inference cost of agentic LLMs by breaking the symmetry in speculative decoding. It uses a lightweight drafter with full context to guide a larger verifier operating on compressed context, mitigating accuracy loss from compression. This asymmetric approach achieves significant speedups while retaining high accuracy, improving the efficiency of agentic LLM pipelines.

AsymSpec speculation step. (a) Drafting & verification: drafter S S reads x full x_{\( \text{full} \)} (logits a a , drafts d 1 : K d_{1:K} ) and x comp x_{\( \text{comp} \)} (logits b b ); verifier L L reads x comp x_{\( \text{comp} \)} (logits t t ). (b) CDA gate & \( \delta \) -fusion: γ eff ​ ( i ) \( \gamma \)_{\( \text{eff} \)}(i) relaxes as full-vs-compressed divergence grows; accepted drafts are committed, otherwise the \( \delta \) -fused arg ⁡ max \( \arg \)\( \max \) is emitted. Only S S consumes x full x_{\( \text{full} \)} .
AsymSpec speculation step. (a) Drafting & verification: drafter S S reads x full x_{\( \text{full} \)} (logits a a , drafts d 1 : K d_{1:K} ) and x comp x_{\( \text{comp} \)} (logits b b ); verifier L L reads x comp x_{\( \text{comp} \)} (logits t t ). (b) CDA gate & \( \delta \)…
cs.AIarxiv:2608.25992v1Lead article

ProgRouter: Online Progress-Guided Orchestration for Multi-Agent LLM Workflows under Quality-Cost Tradeoffs

Somgyuan Li, Ahmed M. Abdelmoniem, Shiqiang Wang

rogRouter addresses the high cost of multi-agent LLM workflows by introducing an online, progress-guided orchestration method. It adaptively selects LLM agents at each step based on a multi-view progress scorer that considers task completion, trends, and state quality. This allows for dynamic routing to maintain task quality while staying within budget constraints.

Overview of LLM agent orchestration in collaborative multi-agent LLM workflows.
Overview of LLM agent orchestration in collaborative multi-agent LLM workflows.
cs.AIarxiv:2608.25920v1Lead article

Repair or Resample? Rethinking Failure Debugging in LLM Multi-Agent Systems

Zhongwen Luan, Xiaoyu Zhang, Ming Hu, Yue Yang, Jiongchi Yu

his paper addresses the reliability bottleneck in LLM-based multi-agent systems (MASs) for complex tasks. It introduces SymTrace, a framework that enables controlled evaluation of repair methods by allowing selective regeneration of MAS execution trajectories after a failure point. This allows researchers to distinguish between causal repair and stochastic improvements due to LLM randomness, contributing a more rigorous approach to debugging MAS failures.

cs.AIarxiv:2608.25973v1Lead article

SciMIF: Understanding Multimodal Instruction Following in Scientific Domains

Ye Shen, Yuting Zheng, Dun Pei, Zijian Chen, Wenlong Zhang

his paper introduces SciMIF, a benchmark for evaluating multimodal instruction following in scientific domains. It proposes a taxonomy of 10 constraint groups derived from analyzing 22 tasks across 5 disciplines, and uses this to systematically augment scientific datasets. The benchmark reveals significant performance gaps, highlighting chemistry as particularly challenging for current MLLMs.

An overview of SciMIF, illustrating its coverage of five scientific disciplines, one general constraint domain, and ten functional constraint categories for constructing diverse scientific instruction-following constraints.
An overview of SciMIF, illustrating its coverage of five scientific disciplines, one general constraint domain, and ten functional constraint categories for constructing diverse scientific instruction-following constraints.
cs.AIarxiv:2608.26081v1Lead article

SwarmWorld: Stigmergic technological evolution in societies of language-model agents

Subhadeep Pal, Fiona Y. Wang, Markus J. Buehler

his paper introduces SwarmWorld, a novel framework where language-model agents collectively evolve technologies through indirect environmental interaction (stigmergy). The core method involves homogeneous agents exploring, resource processing, and constructing artifacts whose functionality is then tested in a deterministic simulator. The key contribution is demonstrating that decentralized LLM agents can self-organize and build functional, evolving technologies without explicit programming or predefined roles, outperforming independent search.

Conceptual lineages leading to SwarmWorld; connectors indicate conceptual convergence rather than direct descent between every adjacent item. (A) Biological collectives and swarm-computing methods contribute decentralized coordination, feedback, and stigmergy. (B) Local-rule models and artificial societies contribute persistent worlds in which local actions alter shared state and generate population-level organization. (C) Distributed-agent and LLM systems contribute explicit agent state, memory-guided planning, embodiment, communication, and reusable executable skills. (D) SwarmWorld combines these elements in a materially constrained multi-agent world where agents build persistent artifacts and inherit or modify their programs. The resulting technological ecology can be evaluated after the agents are removed. Image credits. Ant photograph by Kiran Vati K, CC BY 4.0 , cropped and color-adjusted. Boids still from a video by Andrew Magill, CC BY 2.0 , with a frame extracted, cropped, and color-adjusted. Game of Life glider-gun diagram by Bryan.burgers, public domain , placed on a grid background. Micropolis screenshot based on the original software by Will Wright and Maxis Software/Electronic Arts, the Unix port by Don Hopkins and DUX Software, screenshot by Tomhannen, and edit by bayo; GPLv3 or later with Section 7 additional terms , cropped and color-adjusted. The Sugarscape view, method schematics, and SwarmWorld rendering were created by the authors.
Conceptual lineages leading to SwarmWorld; connectors indicate conceptual convergence rather than direct descent between every adjacent item. (A) Biological collectives and swarm-computing methods contribute decentralized coordination, feedback, and stigmergy. (B) Local-rule mode…
cs.AIarxiv:2608.25775v1Lead article

ToST: A Tree-of-Thought Socratic Teaching Framework for Multi-Path Guidance and Parallel Thinking

Feng Ling, Heng Yu

his paper introduces ToST, a novel framework for Socratic teaching using LLMs. ToST moves beyond single-solution guidance by employing "Parallel Sowing" to encourage students to explore multiple valid approaches to a problem. Its "Multi-Path Adaptive Guidance" then provides flexible, non-linear support across these diverse reasoning paths, enhancing instructional flexibility and error recovery.

Comparison between traditional Socratic Teaching and the proposed ToST paradigm. Traditional method (left) employs a 1P1S paradigm with linear reasoning, susceptible to stalling from intermediate errors. In contrast, ToST (right) adopts a 1PMS paradigm via parallel thinking, enabling dynamic redirection when paths fail.
Comparison between traditional Socratic Teaching and the proposed ToST paradigm. Traditional method (left) employs a 1P1S paradigm with linear reasoning, susceptible to stalling from intermediate errors. In contrast, ToST (right) adopts a 1PMS paradigm via parallel thinking, enab…
cs.CLarxiv:2608.26008v1Lead article

A Self-Evolving Multi-Agent Framework Defense against LLM Jailbreak Attacks

Tongyan Hu, Bryan Hooi

his paper introduces a novel, self-evolving defense framework for LLMs against jailbreak attacks. Its core method involves a persistent rule memory that learns from successful attacks by abstracting their structural wrappers into generalizable rules. This allows the defense to adapt and defend against new, unseen attack strategies without requiring model parameter updates, contributing a dynamic and continuously improving defense mechanism.

Overview of our self-evolving multi-agent defense framework. A1 (Rule Triggering Agent) classifies the input and retrieves relevant rules; A2 (Policy Decision Agent) determines the response policy; A3 (Response Generation Agent) produces the final output; A4 (Self-Reflection Agent) induces new rules when a violation is detected and updates the rule memory base.
Overview of our self-evolving multi-agent defense framework. A1 (Rule Triggering Agent) classifies the input and retrieves relevant rules; A2 (Policy Decision Agent) determines the response policy; A3 (Response Generation Agent) produces the final output; A4 (Self-Reflection Agen…
cs.CLarxiv:2608.26013v1Lead article

VISA: Agentic Self-Evolving Data Synthesis for Multimodal Instruction Following

Min Zeng, Guanxin Tan, Libin Cen, Yawei Wen, Rui Hu

ISA is an agentic framework that synthesizes multimodal instruction-following data through a self-evolving loop. It iteratively generates, verifies, and refines instructions by analyzing images, sampling from memory, and using tools and LLM judges. This approach addresses limitations of one-pass synthesis by incorporating feedback from failed samples and target model errors to create more accurate, diverse, and challenging training data.

Overview of VISA. The framework iteratively performs perception, planning and execution, reflection, and memory update, allowing verifier feedback and target-model difficulty signals to guide subsequent synthesis rounds.
Overview of VISA. The framework iteratively performs perception, planning and execution, reflection, and memory update, allowing verifier feedback and target-model difficulty signals to guide subsequent synthesis rounds.
cs.AIarxiv:2608.27167v1Lead article

Calibrated Enough to Know, Not Calibrated to Act: Fabricated Evidence Makes LLM Agents Commit to the Unknowable

Pranav Aggarwal

his paper demonstrates that Large Language Model (LLM) agents are highly susceptible to fabricated evidence, committing to confidently answer provably unpredictable questions when presented with professional-looking data. The core contribution is showing that the *authority of the packaging* of information, rather than its truthfulness, drives this confident, yet incorrect, action. The LLMs are capable of answering similar, predictable questions accurately, highlighting a specific failure in judgment when faced with seemingly authoritative but false data.

cs.AIarxiv:2608.27142v1Lead article

GRAIN: Bridging Name and Narrative Shifts in Real-World Graph Reasoning through Invariance-Rewarded Agentic RL

Zike Yuan, Han Zhang, Jianzhi Yan, Le Liu, Cai Ke

RAIN addresses LLMs' brittleness to real-world graph reasoning shifts by framing it as a semantic parsing and tool-execution pipeline. Its core contribution is a novel "Structure Invariance Reward" that guides reinforcement learning to learn robust text-to-structure mappings by validating intermediate graph structures against ground truth, outperforming multi-agent approaches.

GRAIN mitigates sensitivity to naming and formulation shifts in real-world graph reasoning via a single-agent tool-use pipeline trained with isomorphism-aware structural rewards .
GRAIN mitigates sensitivity to naming and formulation shifts in real-world graph reasoning via a single-agent tool-use pipeline trained with isomorphism-aware structural rewards .
cs.AIarxiv:2608.27439v1Lead article

RedEvoAgent: Automatic Red-Teaming Agent with Experience-Driven Skill Evolution

Junjie Zhang, Hui Liu, Kecheng Chen, Xianbo Mo, Changsheng Chen

edEvoAgent addresses the limitations of fixed or trajectory-based red-teaming for LLM agents by distilling complex attack trajectories into concise, human-readable "attack skills." Its core method involves adaptively evolving these skills through tool-effectiveness profiling and attribution, guided by a validation process that retains only performance-improving updates. This approach offers a more interpretable and efficient way to discover and generalize jailbreaks compared to existing methods.

RedEvoAgent overview. Given a jailbreak prompt, the attacker agent uses the current attack skill to select and call tools from an extensible attack toolbox, such as GCG and FlipAttack, and iteratively attacks a product-level target agent. On the training split, RedEvoAgent collects successful and failed attack trajectories and independently evaluates each attack tool to build a tool-effectiveness profile. Skill evolution combines the profile with these trajectories to extract tool priorities and attack strategies. A candidate attack skill update is accepted only if it improves attack performance on the validation split, while the test split remains locked for final evaluation.
RedEvoAgent overview. Given a jailbreak prompt, the attacker agent uses the current attack skill to select and call tools from an extensible attack toolbox, such as GCG and FlipAttack, and iteratively attacks a product-level target agent. On the training split, RedEvoAgent collec…
cs.AIarxiv:2608.27141v1Lead article

Safety Does Not Compose: Non-Decaying Loop State for Autonomous LLM Agents

Chenhao Wu, Haoxuan Jia, Yang Liu, Yingguang Yang, Yuhan Lin

his paper argues that current safety mechanisms for autonomous LLM agents fail because they reset safety states between iterations, preventing them from detecting attacks spread across multiple steps. The core contribution is demonstrating that only monitors retaining cross-iteration state can effectively detect such fragmented attacks, as trajectory-scoped monitors will miss crucial evidence. Simply decaying risk scores is also insufficient to address this fundamental compositional safety issue.

cs.AIarxiv:2608.27146v1Lead article

When Tool Outputs Become Commands: Separating Action Induction from Runtime Authorization in Tool-Augmented LLM Agents

Xiaokun Guo, Zhen Xu, Dongdong Huo, Yanqiu Zhang, Wei Wang

his paper addresses the risk of LLM agents executing unintended actions when tool outputs become commands. Their proposed SARA method separates "action induction" (identifying potential actions) from "runtime authorization" (approving their execution). SARA achieves this by isolating action semantics and tracking their origin, while authorizing tool calls solely based on user objectives and verified past successful executions.

SARA’s runtime authorization framework. The user request establishes the authorization root K K ; the Observation-side Action Probe identifies action-inducing semantics and persistently maintains action origins F t F_{t} , which trigger persistent review but do not grant execution authority; authorized and successful tool executions accumulate audited execution evidence H t H_{t} . At the real tool-execution boundary, SARA jointly uses K K , F t F_{t} , and H t H_{t} to authorize the goal, execution chain, and arguments of a candidate call.
SARA’s runtime authorization framework. The user request establishes the authorization root K K ; the Observation-side Action Probe identifies action-inducing semantics and persistently maintains action origins F t F_{t} , which trigger persistent review but do not grant executio…
cs.CLarxiv:2608.27348v1Lead article

INTENT-AS-A-TOOL Makes it Easy to Track Agentic Misalignment

Yutong Zhang, Jianshuo Dong, Peng Xu, Long Wang, Jie Zhang

his paper introduces INTENT-AS-A-TOOL, a method to track agentic misalignment in LLMs by equipping them with specialized "intent tools." By observing the model's commitment to these tools, researchers gain a fine-grained, judge-free signal of its behavioral tendencies. This approach enhances existing chain-of-thought monitoring, providing dense intent trajectories that can identify critical moments for intervention and prevent harmful actions.

cs.AIarxiv:2608.28363v1Lead article

EvoUndo: Recoverability-Constrained Self-Evolution for LLM Agent Harnesses

Tanmay Sah, Dolly Sah, Harshul Jain, Tanya Sah

voUndo addresses the challenge of LLM agents self-modifying their systems, which can lead to irreversible changes. The framework enables the representation, synthesis, diagnosis, and verification of recoverability for these self-modifications across different states. EvoUndo significantly improves the ability to recover from failed mutations compared to conventional methods.

cs.AIarxiv:2608.28361v1Lead article

GRACE:Gradient-guided Coreset Selection for LLM Unlearning

Praveen Bushipaka, Andrea D'Angelo, Lucia Passaro, Tommaso Cucinotta

RACE addresses the challenge of unlearning unwanted knowledge from LLMs when only a few examples of undesired behavior are provided. Its core method is a gradient-guided coreset selection that constructs both forget and retain sets. GRACE first identifies a "forget direction" from seed examples and then selects a compact forget coreset whose gradients align with this direction. It then selects retain examples by projecting out the forget direction to preserve model utility. The contribution is improved model utility during unlearning while maintaining comparable forget quality.

Unlearning pipeline. (1) The user files an unlearning request for a target content contained in the LLM. (2) We use GRACE, our proposed method, to find the best forget and retain coresets to remove the target content while preserving model utility. (3) These two sets are fed to a MU algorithm to perform unlearning.
Unlearning pipeline. (1) The user files an unlearning request for a target content contained in the LLM. (2) We use GRACE, our proposed method, to find the best forget and retain coresets to remove the target content while preserving model utility. (3) These two sets are fed to a…
cs.AIarxiv:2608.28447v1Lead article

Learning to Use Tools: Reinforcement Learning for Tool-Integrated Mathematical Reasoning

Minghui Xu, Zi Wang

his paper introduces a method for improving mathematical reasoning in LLMs by integrating calculator tool use. The core approach involves supervised fine-tuning to teach tool usage patterns, followed by reinforcement learning with automated rewards to optimize performance. The key contribution is demonstrating that this tool integration significantly enhances accuracy on mathematical tasks, specifically the Countdown problem, by mitigating calculation errors.

Schematic of RL for tool-integrated LLM on math reasoning.
Schematic of RL for tool-integrated LLM on math reasoning.
cs.CLarxiv:2608.28476v1Lead article

ContextPilot: Teaching Agents for Proactive Context Management via Fine-grained RL

Zhuoshi Pan, Qizhi Pei, Junru Lu, Honglin Lin, H. Vicky Zhao

ontextPilot addresses the challenge of managing extensive context in long-horizon agentic tasks by introducing a fine-grained Reinforcement Learning (RL) framework. Its core method involves teaching agents to proactively and adaptively manage their working context using a richer toolset and more efficient exploration strategies. The key contribution is enabling LLM agents to better handle dispersed information, overcome limitations of existing methods, and improve overall performance in complex, multi-turn interactions.

Overview of ContextPilot : (a) Extending the context management tools to support planning, long-term memory, and soft context offloading; (b) Improved RL training algorithm with context-aware partial rollout and (c) fine-grained snapshot-level credit assignment.
Overview of ContextPilot : (a) Extending the context management tools to support planning, long-term memory, and soft context offloading; (b) Improved RL training algorithm with context-aware partial rollout and (c) fine-grained snapshot-level credit assignment.
cs.CLarxiv:2608.28378v1Lead article

PersonaForge: Realistic Multi-Turn User Simulation for Agentic Systems

Hanglong Lv, Dawei Zhu, Lei Li, Bowen Ye, Huaqiu Liu

ersonaForge addresses the lack of realistic multi-turn user interaction data for training agentic systems. It synthesizes these interactions by combining a persona space, SOUL-driven behavioral control, and Reverse Deep Construction. This framework generates a novel training dataset and benchmark, significantly improving agent performance on multi-turn tasks.

Overview of PersonaForge: real-session analysis, data synthesis, and benchmark evaluation.
Overview of PersonaForge: real-session analysis, data synthesis, and benchmark evaluation.
cs.AIarxiv:2607.29422v1Lead article

AgenticRepair: Multi-Faceted Program Context Engineering for Agentic Vulnerability Repair

Michael Fu, Qiyue Mei, Patanamon Thongtanunam, Kla Tantithamthavorn

his paper introduces AgenticRepair, a framework for automated vulnerability repair. Its core method is multi-faceted program context engineering, which addresses critical gaps in existing approaches by capturing code structure, runtime execution, and commit history. This richer context is then used by a dedicated repair agent to more effectively patch security flaws.

Comparison of the manual vulnerability remediation workflow (top) versus agentic repair approaches (bottom). Agentic repair approaches take the same triage report (vulnerability description + sanitizer output) already produced by security engineers, automate diagnosis and patch synthesis, and submit the verified patch directly for code review and merge.
Comparison of the manual vulnerability remediation workflow (top) versus agentic repair approaches (bottom). Agentic repair approaches take the same triage report (vulnerability description + sanitizer output) already produced by security engineers, automate diagnosis and patch s…
cs.AIarxiv:2607.29440v1Lead article

Beyond Retrieval: Analytic Memory for Multimodal Agents

Zhoujin Tian, Yao Tian, Hao Zhang, Cheng Chen, Yakun Li

his paper introduces "analytic memory" as a new paradigm for multimodal agents, complementing existing "retrieval memory." Analytic memory allows agents to compute over accumulated observations by organizing recurring multimodal data into queryable structures for filtering, aggregation, and temporal comparison. The proposed AdaMM framework automatically extracts and structures these observations, enabling both retrieval and analytical capabilities for more sophisticated agent reasoning.

Long-term multimodal interaction histories contain observations distributed across sessions, modalities, and time. Answering user queries may require either retrieving specific past events or performing analytical operations, such as temporal selection and aggregation, over multiple observations.
Long-term multimodal interaction histories contain observations distributed across sessions, modalities, and time. Answering user queries may require either retrieving specific past events or performing analytical operations, such as temporal selection and aggregation, over multi…
cs.AIarxiv:2607.29246v1Lead article

Don't Mix Rewards, Mix Policies: Policy Decomposition and Optimization for Multi-Reward RL

Ruiming Liang, Yi Zhong, Yizhen Yuan, Yinan Zheng, Tianyi Tan

his paper proposes PRISM, a novel multi-reward Reinforcement Learning framework for LLMs. Instead of directly optimizing for multiple conflicting rewards, PRISM decomposes the problem by learning separate positive policies for each desired behavior and a single global negative policy. This approach mitigates alignment tax issues and allows for flexible control during inference through policy composition.

Method overview of PRISM
Method overview of PRISM
cs.AIarxiv:2607.29516v1Lead article

From Code Review to Code Critique: Intent, Drift, and Spotlight for AI-Generated Diffs at Scale

Chandra Maddila, Mashrur Rashik, Euna Mehnaz Khan, Smriti Jha, James Saindon

his paper introduces ARCTIC, an AI system designed to improve the review of AI-generated code diffs. It addresses the limitations of current tools by focusing on developer intent, detecting deviations from that intent, and highlighting critical code sections for human attention. ARCTIC's core method involves intent prediction, drift detection via backtranslation, and a spotlight mechanism to prioritize review efforts, significantly enhancing the efficiency and effectiveness of code critique.

Overview of the ARCTIC system. Data sources (left) feed into three layers: the Forest View infers developer intent and detects drift via backtranslation; the Trees View ranks code regions by review-worthiness; and the Foundation provides a taxonomy-guided prioritization based on 18K human code reviews. Outputs (right) combine into a unified reviewer experience supporting self-review and directed peer review.
Overview of the ARCTIC system. Data sources (left) feed into three layers: the Forest View infers developer intent and detects drift via backtranslation; the Trees View ranks code regions by review-worthiness; and the Foundation provides a taxonomy-guided prioritization based on …
cs.AIarxiv:2607.29320v1Lead article

MAGA: Multi-Platform Self-Fusion of GUI Agents via Structured Action Distillation

Hang Yan, Zhangxuan GU, Beitong Zhou, Jiaxuan Chen, Runze Li

AGA addresses the challenge of creating a single GUI agent that works across multiple platforms by introducing a novel distillation method. It focuses on structured action distillation, prioritizing learning from correct actions and suppressing irrelevant signals to improve the agent's ability to execute tasks across different environments. This approach allows for more effective consolidation of specialized GUI agents into a unified, cross-platform policy.

Results from three benchmarks, including MobileWorld (MW), OSWorld (OSW), and WebVoyager (WV). (a) On 900 random samples, we identify 66 tasks where domain-specific models exhibited high disagreement, and weight merging reduces success rate of the merged model by 10%–24%. (b) Success rate of models based on Qwen3-VL-8B across three benchmarks. The horizontal dashed lines mark the domain-specific teachers. Maga is the strongest unified model on every benchmark and exceeds the corresponding domain-specific teacher on OSWorld and WebVoyager.
Results from three benchmarks, including MobileWorld (MW), OSWorld (OSW), and WebVoyager (WV). (a) On 900 random samples, we identify 66 tasks where domain-specific models exhibited high disagreement, and weight merging reduces success rate of the merged model by 10%–24%. (b) Suc…
cs.AIarxiv:2607.29218v1Lead article

MirrorCraft: Paired Evaluation under Hidden Rule Changes in Minecraft

Jianxin Gao, Beini Hu, Runze Li, Wanli Peng, Ruohan Lei

irrorCraft introduces a novel benchmark for evaluating LLM agents in Minecraft by simulating hidden rule changes. Its core method involves creating paired "Mirror" worlds that are identical to "Vanilla" worlds except for modified server-side rules, allowing for controlled assessment of agent adaptability. The key contribution is enabling the evaluation of how well LLM agents can continue to make progress when game mechanics are unexpectedly altered, moving beyond static benchmarks.

Overview of benchmark construction and paired evaluation in Vanilla and Mirror worlds. The paired Mirror world is copied from the Vanilla save, evaluated under matched controls, and loads the datapack for its rule intervention suite.
Overview of benchmark construction and paired evaluation in Vanilla and Mirror worlds. The paired Mirror world is copied from the Vanilla save, evaluated under matched controls, and loads the datapack for its rule intervention suite.
cs.AIarxiv:2607.29431v1Lead article

ModelEquivBench: Certifying Multi-Relational Evaluation of LLM-Generated Optimization Models

Penglin Zhu, Jungang Xu

odelEquivBench introduces a novel, multi-relational evaluation system for LLM-generated optimization models. Instead of a simple equivalence verdict, it provides a detailed semantic profile (E0-E6) assessing various aspects like representation alignment, feasible set relations, and objective equivalence. This approach offers independently verifiable evidence for each relation, enabling more robust and trustworthy evaluation of LLM-generated optimization models.

The ModelEquivBench certifying E ​ 0 E0 – E ​ 6 E6 workflow. E ​ 0 E0 and E ​ 1 E1 establish prerequisites; E ​ 2 E2 – E ​ 6 E6 ask parallel, relation-specific questions. Decided facts carry replayable certificates or witnesses, while unresolved entries remain typed outcomes rather than a global verdict.
The ModelEquivBench certifying E ​ 0 E0 – E ​ 6 E6 workflow. E ​ 0 E0 and E ​ 1 E1 establish prerequisites; E ​ 2 E2 – E ​ 6 E6 ask parallel, relation-specific questions. Decided facts carry replayable certificates or witnesses, while unresolved entries remain typed outcomes rath…
cs.AIarxiv:2607.29468v1Lead article

Self-Play Meets Skill Evolution: Self-Evolving Search Agents that Pose, Solve, and Remember

Zenghuang Fu, Zhaoyang Li, Qiuyuan Ai, Haoyu Wu, Minghui Wu

his paper introduces SESA, a self-play agent that co-evolves problem generation and skill memory. It uses a challenger to pose problems and a solver that retrieves reusable skills from an evolving memory. This bidirectional loop allows the agent to learn and adapt more effectively by continuously refining both its problem-solving abilities and its understanding of past experiences.

Conceptual overview of SESA. Self-posed search failures are not discarded: they are distilled into reusable skills, stored in memory, and fed back to the solver so the next self-play round moves toward harder problems.
Conceptual overview of SESA. Self-posed search failures are not discarded: they are distilled into reusable skills, stored in memory, and fed back to the solver so the next self-play round moves toward harder problems.
cs.AIarxiv:2607.29527v1Lead article

TerraNova: A Foundation Model for the Anthropocene

Carlos Rodriguez-Pardo, Massimo Tavoni

erraNova's core method is a foundation model that unifies physical Earth data and societal data by respecting their distinct geometric representations (continuous fields vs. administrative units). It achieves this through dedicated encoders for location, country, and time, and cross-modal transformers that fuse these into a shared spatiotemporal state. The paper's contribution is a novel approach to modeling the coupled Earth-human system, enabling more accurate predictions by avoiding lossy averaging over borders and directly learning from data in its native geometry.

The physical Earth is observed as continuous fields, whereas societal indicators are reported for discrete administrative units. Both are observations of one shared latent reality.
The physical Earth is observed as continuous fields, whereas societal indicators are reported for discrete administrative units. Both are observations of one shared latent reality.
cs.LGarxiv:2607.29378v1Lead article

PTP: Previous-Token Prediction based LLM Inversion for Near-Exact Prompt Reconstruction

Pirzada Suhail, Nagasai Saketh Naidu, Atanu R Sinha, Amit Sethi

his paper introduces PTP, a novel black-box method for prompt reconstruction from LLM outputs. Instead of semantic reconstruction, PTP trains an explicit inverse language model from scratch using synthetically generated data. This inverse model learns to predict previous tokens, mirroring the forward generation process and enabling near-exact prompt recovery without requiring model weights or external datasets.

Our proposed approach to LLM Inversion using Previous-Token Prediction.
Our proposed approach to LLM Inversion using Previous-Token Prediction.
cs.LGarxiv:2607.29389v1Lead article

Simulation Code Generation for Fluid Systems using Large Language Models: Benchmarking Models and Prompting Strategies

Jan Marius Stürmer, Jascha Knack, Tobias Koch, Andreas Weinmann

his paper explores using Large Language Models (LLMs) to automatically generate simulation code for fluid systems from a neutral graph representation. The core method involves benchmarking ten LLMs and six prompting strategies to translate this representation into executable code for WNTR and Modelica. The contribution is providing concrete guidance on effective LLM configurations for model-based design, demonstrating that specific LLMs and prompting strategies can achieve high functional fidelity in reproducing fluid system scenarios.

Pipeline for automatic generation of simulation-interface layers. A neutral graph of a hydraulic system is combined with contextual material (API docs, stubs, or curated code) and fed to an LLM, which synthesizes a framework-specific wrapper (WNTR Python module or Modelica file). The generated code is then compiled/executed and validated against the ground-truth model.
Pipeline for automatic generation of simulation-interface layers. A neutral graph of a hydraulic system is combined with contextual material (API docs, stubs, or curated code) and fed to an LLM, which synthesizes a framework-specific wrapper (WNTR Python module or Modelica file).…
cs.LGarxiv:2607.29601v1Lead article

The Parts Are Greater Than the Sum: Automated Task Sequencing for Efficient Training of Multi-Policy LLMs

Jiajia Tang, Sizhe Yuen, Francisco Gomez Medina, Yali Du, Adam Sobey

his paper proposes a novel method for training multi-policy Large Language Models (LLMs) efficiently using Parameter-Efficient Fine-Tuning (PEFT). Instead of a single adapter, it automatically organizes tasks into groups and sequences them to create independent Quantized Low-Rank Adapters (QLoRA). This decoupled optimization approach prevents interference between heterogeneous tasks, leading to better transfer learning and avoiding catastrophic forgetting, even with a fixed parameter budget.

Our approach automatically organizes optimization paths through task grouping and task sequencing. These organized paths are implemented using independent QLoRA policies, reducing interference while preserving positive transfer. This indeed provides a new design perspective for parameter-efficient fine-tuning over heterogeneous task sequences.
Our approach automatically organizes optimization paths through task grouping and task sequencing. These organized paths are implemented using independent QLoRA policies, reducing interference while preserving positive transfer. This indeed provides a new design perspective for p…
cs.AIarxiv:2608.02553v1Lead article

A Taxonomy of Cognitive Capability Gaps in Generative and Agentic AI

Taye Akinrele, Sindhuja Penchala, Noorbakhsh Amiri Golilarz, Sudip Mittal, Shahram Rahimi

his paper identifies and categorizes key cognitive capability gaps hindering the development of advanced Cognitive AI, moving beyond simple generation and task execution. It proposes a taxonomy based on five dimensions (state modeling, autonomy, self-monitoring, interaction, and learning) to organize existing research, highlight limitations, and point to future challenges. The core contribution is a structured understanding of these gaps, leading to a conceptual architecture for Adaptive Cognitive Intelligence.

Conceptual evolution from Generative AI to Agentic AI and Cognitive AI, highlighting the additional cognitive capabilities introduced at each stage and the closed-loop perception–reasoning–action cycle underlying sustained cognitive behavior.
Conceptual evolution from Generative AI to Agentic AI and Cognitive AI, highlighting the additional cognitive capabilities introduced at each stage and the closed-loop perception–reasoning–action cycle underlying sustained cognitive behavior.
cs.AIarxiv:2608.02345v1Lead article

Can AI Agents Simulate A/B Test Outcomes? A Validation Framework for Agentic Experimentation

Stefan Hut, Lorenzo Masoero

his paper proposes a framework called Simulated Randomized Controlled Trial (S-RCT) to assess if AI agents can accurately predict A/B test outcomes. The core method involves decomposing simulation errors into agent approximation and subsampling components, allowing for targeted improvements. The contribution is a validated approach that, while currently showing directional accuracy, demonstrates the potential for AI agents to pre-vet A/B test treatments, saving real-world resources.

Principled subsampling: (a) efficiency gain from Neyman allocation grows with stratum variance heterogeneity; (b) for a stylized revenue metric, Neyman allocation achieves a given RMSE with fewer agents; (c) simulation pre-screens a treatment across subgroups, flagging the harmed segment before live deployment.
Principled subsampling: (a) efficiency gain from Neyman allocation grows with stratum variance heterogeneity; (b) for a stylized revenue metric, Neyman allocation achieves a given RMSE with fewer agents; (c) simulation pre-screens a treatment across subgroups, flagging the harmed…
cs.AIarxiv:2608.02397v1Lead article

Can Foundation Models Hear What Made That Sound? A Tiered Benchmark of Audio-Language Models and Traditional Classifiers for Closed-Set Sound Source Identification

Sajjad Abdoli, Ghassan Al-Sumaidaee, Ahmad ElShiekh, Ahmed Rashad

his paper benchmarks various audio classification models, including foundation models and traditional classifiers, on a sound source identification task. It introduces a tiered evaluation approach to account for differing model architectures and output scoring. The contribution lies in providing a comprehensive comparison and identifying that some zero-shot and traditional models can rival or surpass specialized closed-set foundation models in specific scenarios.

Category-level confusion matrix (row-normalized recall) for gemini-3.1-pro-preview , the best-performing Tier A model. The full 23-class fine-grained matrix, where the confusions above are visible in detail, is given in Appendix D (Figure 6 ).
Category-level confusion matrix (row-normalized recall) for gemini-3.1-pro-preview , the best-performing Tier A model. The full 23-class fine-grained matrix, where the confusions above are visible in detail, is given in Appendix D (Figure 6 ).
cs.AIarxiv:2608.02391v1Lead article

Cooperative Coevolution for Resource-Constrained Agentic LLM Post-Training

Zhiyuan Wang, Shengcai Liu, Jiahao Wu, Ning Lu, Hui Ouyang

his paper introduces Cooperative Parameter-subspace Evolution Strategy (CoPES) to address the memory and computational demands of post-training tool-using LLM agents. CoPES decomposes the LLM's parameters into subspaces and searches them cooperatively, significantly improving optimization efficiency. This method achieves high performance with limited GPU resources, recovering 92% of a gradient-based method's performance within the same budget.

Overview of CoPES. At each training step, the model parameters are randomly partitioned into K K disjoint subspaces, and N / K N/K perturbations are evaluated within each subspace under a shared full-model context. Rewards from all subspaces are jointly standardized, and the resulting subspace estimates are composed into a full-parameter update.
Overview of CoPES. At each training step, the model parameters are randomly partitioned into K K disjoint subspaces, and N / K N/K perturbations are evaluated within each subspace under a shared full-model context. Rewards from all subspaces are jointly standardized, and the resu…
cs.AIarxiv:2608.02470v1Lead article

Grounding Agentic VLMs with Dedicated Segmentation for Fine-Grained Vehicle Damage Assessment

Vishwajeet Shivaji Hogale, Anjali Pai, Nitya Ravi

his paper addresses the spatial grounding limitations of Vision-Language Models (VLMs) in fine-grained vehicle damage assessment. Their core method, TinyDamage, separates spatial localization (handled by a dedicated segmentation model) from semantic reasoning (performed by a VLM). This hybrid approach significantly improves the accuracy and reliability of identifying and localizing subtle damages like scratches, overcoming the VLM's inherent weaknesses in precise spatial understanding.

System architecture. Top: multi-task segmentation model with swappable backbone (U-Net, YOLOv8, Mask2Former), FPN encoder, contrastive projection head, gradient-aware boundary module, and auxiliary classifier. Middle: 7-node LangGraph pipeline grounding VLM generation in segmentation output. Bottom: swappable VLM providers and observability infrastructure.
System architecture. Top: multi-task segmentation model with swappable backbone (U-Net, YOLOv8, Mask2Former), FPN encoder, contrastive projection head, gradient-aware boundary module, and auxiliary classifier. Middle: 7-node LangGraph pipeline grounding VLM generation in segmenta…
cs.AIarxiv:2608.02276v1Lead article

Harness-R1: Learning to Edit Executable Runtime Harnesses from Agent Failure Trajectories

Shuai Shao, Kangning Zhang, Qingyao Li, Shijian Wang, Hao Wang

arness-R1 learns to automatically edit an agent's runtime harness by analyzing failure trajectories. It uses a dedicated "harness engineer" trained with reinforcement learning to generate executable patches that improve task success. This approach allows for lifecycle-wide harness improvement beyond just model weight updates.

Matched-baseline reward changes across three benchmarks; diamonds denote the equal-weight average.
Matched-baseline reward changes across three benchmarks; diamonds denote the equal-weight average.
cs.AIarxiv:2608.02254v1Lead article

Homebot: A Personal AI Agent for Conversational Home Assistance and Automation

Shengyuan Ye, Yixin Zhang, Han Liang, Liekang Zeng, Jiangsu Du

omebot is a locally deployable AI agent that provides conversational home assistance and automation. Its core method involves a shared runtime that integrates language model responses with registered tools and skills, processing both voice and instant messaging requests. The key contribution is a flexible and customizable system for hands-free home control, with distinct handling for voice and text interactions and clear interfaces for easy integration of new functionalities.

Figure 1. System overview of Homebot . User-facing channels route normalized messages through the message bus to the agent runtime, which constructs context, invokes tools and skills, and retrieves or persists channel-scoped session history.
Figure 1. System overview of Homebot . User-facing channels route normalized messages through the message bus to the agent runtime, which constructs context, invokes tools and skills, and retrieves or persists channel-scoped session history.
cs.AIarxiv:2608.02518v1Lead article

Magnet: Detecting Cross-Session AI Misuse Through Capability Accumulation

Natalie Isak, Matthew Dressman

his paper introduces "Magnet," a method for detecting AI misuse that spans multiple independent agent sessions. Its core idea is to track the accumulation of capabilities an attacker builds across these sessions, which are otherwise invisible to single-session detection systems. Magnet's contribution lies in identifying this novel cross-session attack vector and providing a mechanism to counter it by recognizing the emergent, harmful potential of sequentially executed innocuous actions.

The data generation pipeline. An expert-authored decomposition of target objective T T into sub-capabilities c 1 , … , c n c_{1},\( \ldots \),c_{n} is dispatched sequentially, with each subtask handled by a freshly instantiated assistant–user agent pair that iterates until the subtask produces a completed artifact.
The data generation pipeline. An expert-authored decomposition of target objective T T into sub-capabilities c 1 , … , c n c_{1},\( \ldots \),c_{n} is dispatched sequentially, with each subtask handled by a freshly instantiated assistant–user agent pair that iterates until the su…
cs.AIarxiv:2608.02409v1Lead article

MonitrLLM: A Community-Centered Evaluation Infrastructure for Large Language Models

Victor Ojewale, Ro Encarnación, Suresh Venkatasubramanian, Danaé Metaxa

onitrLLM is an open-source infrastructure that bridges a critical gap in LLM evaluation by linking full conversation transcripts with user-defined task intents and outcome assessments. Its core method treats these three elements as primary evaluative signals, enabling a more holistic understanding of LLM performance. The contribution lies in providing a community-centered approach to evaluate LLMs based on real-world user interactions and their success in achieving user-defined goals.

The MonitrLLM browser extension where users submit an audit report through a five-field form capturing interaction description, task purpose, outcome assessment, conversation share link, and a 1-to-5 satisfaction rating.
The MonitrLLM browser extension where users submit an audit report through a five-field form capturing interaction description, task purpose, outcome assessment, conversation share link, and a 1-to-5 satisfaction rating.
cs.AIarxiv:2608.02287v1Lead article

SKT: Skill-Use Training at Scale via Verified Synthetic Data Generation

Zelin Tan, Yiqun Zhang, Hao Li, Zhiyao Cui, Hejia Geng

his paper introduces SKT, a method for generating verified synthetic data to train language-model agents on how to effectively use skills. SKT constructs tasks and executable trajectories by selecting skill combinations, synthesizing them with rule-based and agent-based verification, and retaining only successful executions. This approach significantly improves agent skill-use capabilities and enables the creation of a new benchmark, SkillEval, for evaluating these abilities.

SKT is a multi-agent-based data synthesis pipeline for skill-use tasks and trajectories. Training on data synthesized by SKT can effectively improve agents’ ability to use Agent Skills.
SKT is a multi-agent-based data synthesis pipeline for skill-use tasks and trajectories. Training on data synthesized by SKT can effectively improve agents’ ability to use Agent Skills.
cs.AIarxiv:2608.02499v1Lead article

SWE-Touch: Benchmarking Coding Agents When Users Touch the Code

Yuqiao Tan, Jinxiang Meng, Fangyu Lei, Minzheng Wang, Shizhu He

his paper introduces SWE-Touch, a new benchmark for evaluating coding agents in collaborative environments where users can modify code. Its core method involves introducing "Counter-Edits" – plausible code changes that hinder task completion – to test how agents react to real-time user modifications. SWE-Touch's contribution is to provide a more realistic assessment of coding agents by simulating shared development workflows, revealing that these agents struggle with unexpected code alterations.

cs.AIarxiv:2608.02302v1Lead article

Trajectories That Segment Themselves: Agent-Declared Boundaries as a Training Unit

Jingxi Wei

his paper proposes a novel method for training AI agents by having them self-segment their trajectories into meaningful phases during generation. The core idea is to use "declarative contracts" where the agent declares its own boundaries based on falsifiable causal hypotheses. This approach generates richer training data, including "wrong-cause-then-correction" transitions and audit supervision from discarded regions, which are typically lost in standard episodic training.

A code-blind reader finds boundaries; a mechanical rule with the same access does not. Boundaries matched out of 40, against what the same number of randomly placed marks would match on the same trajectories. Neither the sparse nor the permissive test-event rule beats its own chance baseline, at either end of the sweep. No observer is told how many boundaries to expect.
A code-blind reader finds boundaries; a mechanical rule with the same access does not. Boundaries matched out of 40, against what the same number of randomly placed marks would match on the same trajectories. Neither the sparse nor the permissive test-event rule beats its own cha…
cs.LGarxiv:2608.02515v1Lead article

LiveMem: Maintaining Memory State Continuity in Long-Running LLM Inference

Zhichen Liu, Ruihan Sun, Hengjie Yang, Zipeng Wu, Zhaohan Chen

iveMem addresses the challenge of maintaining long-term memory for LLMs by introducing a novel "state continuity under context turnover" mechanism. Its core method augments a standard LLM with a persistent, intrinsic memory state that preserves historical information independently of the active context window. This allows LLMs to carry computation forward across extended interactions, enabling them to retain knowledge and perform effectively even as the immediate context changes.

LiveMem enables stateful continual inference under context turnover. A bounded working context provides precise short-term access, while a fixed-capacity recurrent memory state preserves information across the model lifecycle.
LiveMem enables stateful continual inference under context turnover. A bounded working context provides precise short-term access, while a fixed-capacity recurrent memory state preserves information across the model lifecycle.
cs.LGarxiv:2608.02508v1Lead article

RoMeRL: Balancing Feedback Coverage and the Memory-Reward Trap in Self-Evolving Agent Memory via Reduced-Order Utility States

Yi Yang, Zhennan Chen, Yihong Zhuang, Tiehan Fan, Yinan Chen

his paper introduces RoMeRL, a novel method for self-evolving LLM agent memory. RoMeRL addresses the challenges of feedback dispersion and the memory-reward trap by representing memory utilities with a fixed-dimensional state factorized by outcome polarity and memory dynamics. This approach concentrates feedback, leading to more effective learning and avoiding misleading utility updates for irrelevant experiences.

Memory-reward trap : Stronger exploration retrieves more low-access-count memories, including weakly relevant, noisy, outdated, or failed experiences. When such a memory appears in a successful episode, the shared trajectory reward can promote it despite no causal contribution. Exploration therefore increases feedback coverage but also raises the risk of reward misattribution.
Memory-reward trap : Stronger exploration retrieves more low-access-count memories, including weakly relevant, noisy, outdated, or failed experiences. When such a memory appears in a successful episode, the shared trajectory reward can promote it despite no causal contribution. E…
cs.AIarxiv:2608.03958v1Lead article

A game theory for foundation models shows new paths to rational cooperation through similarity inference

Alexander Meulemans, Maciej Wołczyk, Marissa A. Weis, Rajai Nasser, Roberta Rocca

his paper introduces a new game theory framework for foundation model agents, moving beyond classical assumptions of independent decision-making. The core method involves modeling agents as "embedded Bayesian agents" that jointly predict their actions with environmental observations. This shift reveals that foundation model agents, when planning optimally, naturally converge to stable cooperation in social dilemmas, a significant contribution that challenges traditional game-theoretic predictions of mutual defection.

cs.AIarxiv:2608.03794v1Lead article

Evaluating LLMs in Database Scenarios: A Lifecycle Benchmark for Assessing Their Potential in Core Database Tasks

Shunfan Zheng, Dongsheng Shi, Yue Li, Xin Yi, Linlin Wang

his paper introduces DBLifeBench, the first benchmark to evaluate LLMs across the entire database lifecycle, from design to maintenance, addressing the limitations of current Text-to-SQL focused evaluations. It also proposes Progressive-Text2SQL, a novel task using reasoning graphs to improve LLM performance on complex SQL generation by mimicking human iterative problem-solving.

Comparison between traditional Text-to-SQL-centric benchmarks and our holistic DBLifeBench. While existing benchmarks focus solely on query translation, DBLifeBench covers the full spectrum of a DBA’s workflow.
Comparison between traditional Text-to-SQL-centric benchmarks and our holistic DBLifeBench. While existing benchmarks focus solely on query translation, DBLifeBench covers the full spectrum of a DBA’s workflow.
cs.AIarxiv:2608.03733v1Lead article

Failure-Informed Image Self-Augmentation for Multimodal Large Language Model Self-Improvement

Chunyang Jiang, Pingping Zhang, Yuzhi Zhao, Wenao Ma, Zhijian Hou

his paper introduces Failure-Informed Image Self-Augmentation (FISA), a novel method for MLLMs to improve themselves using their own mistakes. FISA generates challenging, yet semantically preserved, image augmentations from failure cases, then verifies their usefulness and filters out distorted examples. This approach addresses the limitations of text-centric self-augmentation and generic image transformations, leading to better MLLM performance.

Instruction template for failure-oriented image complication.
Instruction template for failure-oriented image complication.
cs.AIarxiv:2608.03764v1Lead article

GDPevo: Evaluating Agent Self-Evolution on Real Business Tasks

Leijun Zhou, Zhihao Liu, Xiang Qu, Chenxu Liu, Yifei Liu

his paper introduces GDPevo, a novel benchmark for evaluating agent self-evolution on real-world business tasks. Its core method, rule hybridization, breaks down enterprise workflows into atomic rules, distributing them across training tasks and recombining them in test tasks to isolate the impact of learned experience. GDPevo's contribution lies in providing a robust evaluation framework for self-evolving agents across diverse business domains, addressing limitations of existing benchmarks.

The GDPevo data construction pipeline. Every agent in this pipeline uses the same harness and model, Codex with GPT-5.5, but each runs as a separate instance with its own context, so the agents remain relatively independent.
The GDPevo data construction pipeline. Every agent in this pipeline uses the same harness and model, Codex with GPT-5.5, but each runs as a separate instance with its own context, so the agents remain relatively independent.
cs.AIarxiv:2608.03892v1Lead article

Intertemporal Preference Steering in Qwen3 via Contrastive Activation Addition

Michal Mráz, Justin Shenk

his paper identifies linear directions in the Qwen3 model's internal representations that correspond to short-term versus long-term preferences. By training contrastive probes on temporal choice data, they discover these directions and then use "contrastive activation addition" to steer the model's behavior. This method successfully induces significant, bidirectional changes in the model's intertemporal decision-making, demonstrating control over its time-related preferences and capabilities.

Layerwise explicit-trained probe accuracies from the probe-variation experiment. The left panel reports explicit test set accuracy; the right panel reports full implicit set accuracy.
Layerwise explicit-trained probe accuracies from the probe-variation experiment. The left panel reports explicit test set accuracy; the right panel reports full implicit set accuracy.
cs.AIarxiv:2608.03782v1Lead article

KnowHal: A Knowledge-Driven Benchmark for Comprehensive Multimodal Hallucination Evaluation

Ruihan Li, Jiyang Tan, Kailin Jiang, Huining Li, Hengyang Lu

his paper introduces KnowHal, a novel benchmark designed to comprehensively evaluate multimodal hallucination in LLMs. KnowHal expands beyond existing evaluations by incorporating "knowledge hallucination" alongside entity, attribute, and relation hallucinations. Its core method involves creating paired positive and negative questions over images and entities to isolate different error types, contributing a unified framework for more robust MLLM trustworthiness assessment.

Illustration of two types of hallucination in MLLMs: perceptual-level hallucination (a–c) involves the Entity, Attribute, and Relation dimensions, while knowledge-level hallucination (d) introduces the Knowledge dimension, requiring external world knowledge beyond visual perception.
Illustration of two types of hallucination in MLLMs: perceptual-level hallucination (a–c) involves the Entity, Attribute, and Relation dimensions, while knowledge-level hallucination (d) introduces the Knowledge dimension, requiring external world knowledge beyond visual percepti…
cs.AIarxiv:2608.03689v1Lead article

LiveEvalBench: Toward Open-World Evaluation for Web Generation

Yiyao Wang, Zhen Wen, Yinghao Tang, Yixiao Fu, Lin Yuan

his paper introduces LiveEvalBench, a novel framework for evaluating web generation by large language models. It shifts from static evaluation to an agentic, adaptive process that mimics a collaborative review workflow involving build, code, and UI engineers. This approach accounts for the interactive nature of frontend projects, their diverse valid implementations, and their rapid evolution, offering a more comprehensive and realistic evaluation.

LiveEvalBench versus prior web coding benchmarks. While prior works treat evaluation as a one-shot scoring procedure, LiveEvalBench models it as a collaborative expert review workflow with complementary agents, an adaptive protocol, and an extensible framework.
LiveEvalBench versus prior web coding benchmarks. While prior works treat evaluation as a one-shot scoring procedure, LiveEvalBench models it as a collaborative expert review workflow with complementary agents, an adaptive protocol, and an extensible framework.
cs.AIarxiv:2608.03844v1Lead article

MAFIA: Query-Only Memory Attacks via Probing and Factual Injection against Audited LLM Agents

Jiaming Chen, Yisen Gao, Yanping Li, Zifan Liu, Yumeng Zhang

AFIA is a novel query-only attack framework designed to poison the memory of LLM agents. It overcomes limitations of existing methods by using memory probing to ensure injected malicious records are retrieved and factual cloaks to bypass input auditing, effectively maintaining malicious effects while remaining semantically inconspicuous. This work's core contribution is a practical and effective method for memory poisoning in realistic, audited LLM agent environments.

Two deployment pressures we evaluate. (a) LLM audit detection rate (DR) on MAFIA (Ours) and MINJA memory entries. (b) ASR of both methods across the evaluated benign-memory sizes on eICU Pair 1. Each sweep point evaluates 30 victim queries; lines connect observed points, and crosses mark the full-pool results at size b = 5 , 842 b{=}5{,}842 .
Two deployment pressures we evaluate. (a) LLM audit detection rate (DR) on MAFIA (Ours) and MINJA memory entries. (b) ASR of both methods across the evaluated benign-memory sizes on eICU Pair 1. Each sweep point evaluates 30 victim queries; lines connect observed points, and cros…
cs.AIarxiv:2608.03972v1Lead article

ReflectRL: Learning from Golden Negative Trajectories via Reflective-to-Direct Reasoning

Jinhe Bi, Chennan Zhou, Zengjie Jin, Aniri, Shuo Lu

eflectRL introduces a novel approach to improve large language model reasoning by learning from "Golden Negative Trajectories" – expert model failures on difficult problems. Instead of discarding these failures, ReflectRL treats them as opportunities for reflection. The core method involves a lightweight framework that elicits reflective reasoning from these flawed trajectories, arguing that reflecting on mistakes can be more effective than direct problem-solving for complex tasks.

Understanding the Reflection Advantage through behavioral, descriptive, and intervention evidence on Qwen2.5-Math-7B. (a) Behavioral Evidence : Reflection Gain Δ ref = 𝔼 o ∼ π ​ [ r ​ ( q , o ) ∣ q , o − ] − 𝔼 o ∼ π ​ [ r ​ ( q , o ) ∣ q ] \( \Delta \)_{\( \text{ref} \)}=\( \mathbb{E}_{o\sim\pi} \)[r(q,o)\( \mid \) q,o^{-}]-\( \mathbb{E}_{o\sim\pi} \)[r(q,o)\( \mid \) q] over training steps. Reflecting on a GNT yields the largest gain, which steadily grows during training, whereas self-failures offer limited benefits, and weak-model failures or mismatched GNT (incase length bias) leads to negative gain. (b) Descriptive Evidence : Qwen2.5-Math-PRM-7B score profiles of failure sources and process metrics (inset). GNT maintains a higher valid prefix of reasoning compared to other failure sources before dropping at localized error points. (c) Intervention Evidence : Ablation of GNT trajectory components. Both the valid prefix and the error region causally drive the reflection gain, whereas removing these components (Shuffled GNT, Answer Only) reduces accuracy below the direct baseline.
Understanding the Reflection Advantage through behavioral, descriptive, and intervention evidence on Qwen2.5-Math-7B. (a) Behavioral Evidence : Reflection Gain Δ ref = 𝔼 o ∼ π ​ [ r ​ ( q , o ) ∣ q , o − ] − 𝔼 o ∼ π ​ [ r ​ ( q , o ) ∣ q ] \( \Delta \)_{\( \text{ref} \)}=\( \ma…
cs.AIarxiv:2608.03745v1Lead article

Risky Business: Measuring The Faithfulness-Safety Tension

Dominik Meier, Luca Joshua Francis, Marco Bernhard Kaiser, Terry Ruas, Jan Philip Wahle

his paper identifies a tension in Large Reasoning Models (LRMs) between being faithful to their reasoning traces for monitoring and being robust enough to reject unsafe reasoning. To address this, they introduce HazMart, a dataset for testing this tension, and a novel technique called Targeted Reasoning Replacement (TRR) that directly manipulates reasoning chains to assess model safety.

Example prompts from the HazMart dataset.
Example prompts from the HazMart dataset.
cs.AIarxiv:2608.03970v1Lead article

Should We Type or Talk to LLM Agents? A Comprehensive Study of Voice and Keyboard Input Perturbations

Zizhao Hu, Nathan Elijah Segura, Mohammad Rostami, Jesse Thomason

his paper investigates how voice and keyboard input affect LLM performance. Their core method, HIVE, introduces realistic noise to both input types and evaluates model robustness. The key contribution is identifying that the loss of original question tokens, rather than added noise or fillers, is the primary driver of performance degradation for LLMs.

The HIVE taxonomy at a glance. A user either ad-libs a question or passes existing information along, and it reaches the model through voice, a QWERTY keyboard, or copy-paste, which delivers the question verbatim and is the clean reference. Colour marks the channel, not how an operator is built: the voice operators are a mix of few-shot LLM style transfer and deterministic rules, and the keyboard operators are all deterministic. Every example shown is a real item from the released data. The right panel shows how a model replies under degraded input. Table 4 gives the full specification.
The HIVE taxonomy at a glance. A user either ad-libs a question or passes existing information along, and it reaches the model through voice, a QWERTY keyboard, or copy-paste, which delivers the question verbatim and is the clean reference. Colour marks the channel, not how an op…
cs.AIarxiv:2608.03910v1Lead article

Socially Grounded Agentic AI: Coordinating Plural Perspectives through Social Theory

Matt Ratto, Abhishek Moturu, Daniel Silver

his paper proposes "Socially Grounded Agentic AI" to address pluralistic alignment by leveraging social theory. The core method involves understanding and representing diverse AI perspectives as structured by social roles, shaped by interaction, and influenced by power dynamics. The main contribution is providing a framework for AI to coordinate these plural perspectives, moving beyond single-value optimization for real-world social deployment.

cs.LGarxiv:2608.03929v1Lead article

Latent Reward Registers for Diffusion Preference Alignment

Yuanshen Guan, Zipeng Feng, Zhiwei Xiong, Peiqin Sun

his paper introduces Latent Reward Registers to address the temporal credit assignment problem in aligning diffusion models with human preferences. By prepending learnable tokens to intermediate noisy latents, the method estimates terminal preferences without altering the diffusion model's internal states. This provides a dense, differentiable reward signal that enables efficient training via Reward-Gradient On-Policy Distillation and guided sampling during inference.

Latent Reward Registers vs. existing paradigms. Unlike conventional alignment methods that rely on delayed, sparse feedback from a clean image (Left) or require intrusive fine-tuning of the generator (Middle), our approach (Right) appends learnable registers to a frozen DiT. This enables the direct estimation of step-wise rewards from intermediate noisy latents ( z t z_{t} ). Consequently, we derive dense, differentiable reward gradients ( ∇ R \( \nabla \) R ) for generation while keeping the pretrained generative dynamics fully intact.
Latent Reward Registers vs. existing paradigms. Unlike conventional alignment methods that rely on delayed, sparse feedback from a clean image (Left) or require intrusive fine-tuning of the generator (Middle), our approach (Right) appends learnable registers to a frozen DiT. This…
cs.AIarxiv:2608.04872v1Lead article

A-SR: Self-Evolving Agentic LLMs for Symbolic Regression via Hierarchical Coordination

Wenxiao Zhao, Dong Liu, Kaiyi Xu, Feng Liu, Zhen Zhao

-SR introduces a novel self-evolving agentic framework for symbolic regression that moves beyond single-prompt approaches. Its core method involves coordinating specialized LLM agents through role-conditioned evidence views and hierarchical coordination protocols, enabling more effective exploration of the search space. The key contribution is a dynamic, adaptive system that learns from evaluator feedback to refine its search process within a run and distills successful strategies into proposal priors for future runs.

Agentic feedback-driven coordination in A-SR. A-SR converts validity, improvement, failure, and complexity signals into coordination decisions over protocol, role, and routed memory, forming the context for the next equation.
Agentic feedback-driven coordination in A-SR. A-SR converts validity, improvement, failure, and complexity signals into coordination decisions over protocol, role, and routed memory, forming the context for the next equation.
cs.AIarxiv:2608.05102v1Lead article

ABSeeker: Training Long-Horizon Search Agents via Answer-Backtracked Credit Assignment

Yijun Lu, Rui Ye, Jiajun Wang, Yuwen Du, Tian Jin

BSeeker trains long-horizon search agents by assigning credit at a finer, step-level rather than trajectory-level. Its core method, Answer-Backtracked Credit Assignment (ABC), recovers intermediate clues from the ground-truth answer to generate dense supervision. This allows the agent to learn which actions are truly useful, even in failed trajectories, by rewarding correct steps and penalizing errors or redundancy.

ABSeeker achieves the best performance among 4B models and remains competitive with several larger search agents. Striped regions indicate results with context management enabled.
ABSeeker achieves the best performance among 4B models and remains competitive with several larger search agents. Striped regions indicate results with context management enabled.
cs.AIarxiv:2608.04788v1Lead article

Agentic Reinforcement Learning with Observation-Calibrated Self-Distillation

Yi Yang, Cong Qin, Xiaodan Liu, Chishui Chen, Qing Dong

his paper introduces Observation-Calibrated Self-Distillation (OCSD) to improve reinforcement learning for large language model agents. OCSD addresses a limitation of prior methods by disentangling the influence of privileged information from the replay process itself. It achieves this by contrasting two replay views, one with full information and one with crucial future observations removed, to isolate the true value of the privileged data.

Deriving the observation residual from structurally matched replay views.
Deriving the observation residual from structurally matched replay views.
cs.AIarxiv:2608.05026v1Lead article

ArtAnno: Annotating Implicit Semantics in Artworks through LLM Agent-Driven Bidirectional Human-AI Augmentation

Xiaoyan Gu, Yifang Wang, Wenqing Zheng, Haozhong Liu, Yixia Zheng

rtAnno introduces Bidirectional Human-AI Augmentation (BiHAA), a closed-loop framework for annotating implicit artwork semantics. It leverages a multi-agent LLM system where AI proactively suggests semantic labels and humans refine them, creating a continuous feedback loop that enhances both AI capabilities and human annotation efficiency. This approach addresses the limitations of one-way AI assistance in capturing complex, culturally-grounded meanings in art.

Figure 1. Comparison between the Bidirectional Human-AI Augmentation Framework (BiHAA) and traditional frameworks. (A-B) Left block represents input, right one represents output. (C) Both blocks serve as input and output.
Figure 1. Comparison between the Bidirectional Human-AI Augmentation Framework (BiHAA) and traditional frameworks. (A-B) Left block represents input, right one represents output. (C) Both blocks serve as input and output.
cs.AIarxiv:2608.05124v1Lead article

Chained Recursive Language Models for Multi-Iteration Reasoning

Purbesh Mitra, Sennur Ulukus

his paper introduces Chained Recursive Language Models (Chained RLM), an inference-time architecture that breaks down complex reasoning tasks into smaller, manageable steps. Instead of a single, long inference, Chained RLM repeatedly calls the same model with the original problem and context, but provides each new "reasoning root" with a concise summary and a shared "blackboard" of intermediate results. This approach aims to mitigate error propagation and improve performance on multi-step reasoning tasks by allowing the model to focus on distinct sub-problems at each stage.

Chained RLM architecture with 3 RLM calls.
Chained RLM architecture with 3 RLM calls.
cs.AIarxiv:2608.05045v1Lead article

Gradient Immunity: Null-Space Resistance to Malicious Fine-Tuning

Yuxuan Huang, Xingyu Zeng, Tianhang Zheng, Chaochao Lu

his paper introduces "Gradient Immunity" to defend against malicious fine-tuning of open-weight language models. Their core method, the Unidirectional Safety Gate (USG), uses a novel cubic layer to block harmful gradients and an inverse adapter to preserve normal model behavior. This approach protects safety-critical components in a partially protected open-weight release setting, a scenario not addressed by prior defenses.

The figure illustrates the idealized behavior of a USG-style safeguard. For harmful data, it functions as a diode: during backpropagation, the USG sets gradients to zero, inducing gradient vanishing and thereby blocking gradient propagation. For safe data, it acts as a wire without inducing gradient vanishing in the idealized exact-blocking definition. Its core idea is the controllable induction of gradient vanishing—normally an undesirable behavior in model training.
The figure illustrates the idealized behavior of a USG-style safeguard. For harmful data, it functions as a diode: during backpropagation, the USG sets gradients to zero, inducing gradient vanishing and thereby blocking gradient propagation. For safe data, it acts as a wire witho…
cs.AIarxiv:2608.04761v1Lead article

InsightEmb: Learning Action-Intent Embeddings for Agentic Insight Retrieval

Tsz Ting Chung, Jiangnan Li, Jie Zhou, Mo Yu

his paper introduces InsightEmb, a novel method for agentic insight retrieval. Unlike previous approaches focusing on semantic similarity, InsightEmb learns embeddings that capture the "progress-oriented" nature of insights, meaning it retrieves insights that help an agent overcome its current decision-making challenges. Its core contribution is a contrastive learning framework that aligns concrete situations with abstract rules and clusters reasoning trajectories based on their progress, enabling effective insight retrieval without environment-specific training.

InsightEmb retrieves insights that resolve the agent’s current procedural bottleneck rather than topical overlap alone. Left: the abstraction gap and shared situation-to-insight structure across math and embodied tasks. Right: on an ALFWorld “hot potato” task, Base favors heating rules before the object is found, whereas InsightEmb retrieves search-first guidance.
InsightEmb retrieves insights that resolve the agent’s current procedural bottleneck rather than topical overlap alone. Left: the abstraction gap and shared situation-to-insight structure across math and embodied tasks. Right: on an ALFWorld “hot potato” task, Base favors heating…
cs.AIarxiv:2608.05131v1Lead article

OPD-V: Visual On-Policy Self-Distillation with Modality Balance

Aniri, Jinhe Bi, Peng Liao, Zengjie Jin, Volker Tresp

his paper introduces OPD-V, a novel visual on-policy self-distillation method for multimodal large language models (MLLMs). It addresses the issue of modality imbalance, where text often dominates, hindering full multimodal integration. OPD-V leverages the concept of modality balance itself as privileged information, using a "Positive Teacher" (Zoom-In Image) to guide distillation and improve visual reasoning.

Modality Balance as privileged information, evaluated on 5K samples drawn from multiple domains. Left: the Modality-Balance Attention Ratio is lowest for the Negative Teacher with the Mask Image, intermediate for the student with the Original Image, and highest for the Positive Teacher with the Zoom-In Image. These matched conditions expose distinct degrees of Modality Imbalance. Right: as the Modality-Balance Logits Margin increases, the gap between the Positive and Negative Teacher attention ratios widens, accompanied by higher student correctness. For each margin interval b b , the blue curve reports Δ ​ ρ b = | b | − 1 ​ ∑ i ∈ b [ ρ ​ ( c + ; y i ) − ρ ​ ( c − ; y i ) ] \( \Delta \)\( \rho_{b} \)=|b|^{-1}\( \sum_{i\in b} \)[\( \rho \)(c^{+};y_{i})-\( \rho \)(c^{-};y_{i})] , where y i y_{i} is the response trajectory for sample i i , and c + c^{+} and c − c^{-} denote the Zoom-In Image and Mask Image conditions, respectively.
Modality Balance as privileged information, evaluated on 5K samples drawn from multiple domains. Left: the Modality-Balance Attention Ratio is lowest for the Negative Teacher with the Mask Image, intermediate for the student with the Original Image, and highest for the Positive T…
cs.AIarxiv:2608.04999v1Lead article

ORACLE: A Multi-Objective Reinforcement Learning-Based Analog Circuit Design Optimizer with Large Language Models-Guided Exploration

Osei Brempong, Mohammed Ayman Habib, Vivan Poddar, Morteza Fayazi

RACLE is a novel reinforcement learning framework for analog circuit design that addresses the limitations of single-objective optimization and scalar reward reduction in multi-objective problems. It employs vector-valued learning and preference-aware conditioning, allowing users to specify desired trade-offs with a preference vector. This enables ORACLE to find true Pareto optimal designs and adapt to changing specifications without retraining.

Overall ORACLE framework.
Overall ORACLE framework.
cs.AIarxiv:2608.04980v1Lead article

Protoreasoning in Tiny Transformers

Eduardo Valle, Fergal Reid

his paper introduces "protoreasoning," a simplified Chain of Thought method applied to tiny transformer models. By using reasoning-friendly tasks on Dyck languages, the authors demonstrate that these small models can learn to generalize better out-of-distribution when employing protoreasoning. This approach allows for detailed analysis of step-by-step reasoning in models much smaller than typical LLMs, offering insights into how such reasoning is learned.

cs.AIarxiv:2608.04804v1Lead article

Scrouting: Cost-Aware Routing of Coding Agents by Scouting the Repository First

Ishaan Bhola, Adithyan Krishnan, Mukunda NS

his paper introduces SuperScout, a cost-aware routing method for coding agents. It first uses a "searcher" model to explore the software repository, identifying relevant information and verifying claims. This scouted information, along with the task description, then guides a "router" to select the most appropriate "fixer" model, significantly reducing the cost per solved issue while maintaining high performance.

cs.LGarxiv:2608.04968v1Lead article

EvolveNet: Collaborative Harness Evolution for Agent Self-Improvement

Jun Nie, Yonggang Zhang, Qianshu Cai, Yiu-ming Cheung, Xinmei Tian

volveNet introduces a novel method for improving LLM agents by collaboratively evolving their "harness" (the program that manages context, tools, and execution). Instead of a single optimizer processing all experience, EvolveNet distributes harness evolution to local agent deployments. This allows each deployment to adapt the harness to its specific workload, and then these localized adaptations are composed to create a more robust and universally improved harness.

Left: conventional harness evolution is sequential. One optimizer consumes incoming batches in order and each harness must be produced before the next can be explored, so a T T -stage search has serial depth T T and follows a single trajectory. Right: EvolveNet broadcasts the shared harness h ( t ) h^{(t)} to K K clients, which evolve it in parallel on the workloads held at each, into specialists h k ( t ) h_{k}^{(t)} . The server aggregates the returned programs rather than the workloads behind them, adopting a mechanism globally when its supporting evidence spans domains and conditioning it on its home domain otherwise, and commits the result as h ( t + 1 ) h^{(t+1)} only if it passes the per-item acceptance test (Sec. 4.4 ). The dashed edge closes the loop: the committed harness is redistributed, so each client’s next round of evolution starts from what the whole collaboration has learned, not from its own previous program.
Left: conventional harness evolution is sequential. One optimizer consumes incoming batches in order and each harness must be produced before the next can be explored, so a T T -stage search has serial depth T T and follows a single trajectory. Right: EvolveNet broadcasts the sha…
cs.LGarxiv:2608.05080v1Lead article

Optimizing What Policies Learn From: Recoverability-aware Rollout Intervention Learning

Zheyuan Zhang, Manqing Mao, Hong Wang, Zhuoer Wang, Samson Koelle

his paper introduces Recoverability-Aware Intervention Learning (RAIL), a framework that optimizes how reinforcement learning policies learn from rollouts. Instead of uniform rollout allocation, RAIL dynamically selects and intervenes in rollouts based on their predicted learning improvement, treating it as an online contextual-bandit problem. This approach allows for adaptive intervention strategies that evolve with the policy, leading to more efficient and effective learning.

Performance-rollout Results Preview on AgentBench. RAIL achieves the highest success rates with comparable or fewer rollouts than uniform GRPO and adaptive intervention baselines on OS task (Left) and DB task(right). More results on further benchmarks and analysis in Section 4 .
Performance-rollout Results Preview on AgentBench. RAIL achieves the highest success rates with comparable or fewer rollouts than uniform GRPO and adaptive intervention baselines on OS task (Left) and DB task(right). More results on further benchmarks and analysis in Section 4 .
cs.LGarxiv:2608.05033v1Lead article

SparseDitto: Customizing GPU Kernels for Different Sparsity Patterns with LLM-Based Agentic System

Shiyang Li, Guangyan Sun, Jinwei Tang, Yanzhi Wang, Mingyi Hong

parseDitto is an LLM-based system that automatically generates customized GPU kernels for sparse matrix operations. It addresses the performance variability of existing libraries by adapting the matrix representation, execution strategy, and hardware mapping to specific sparsity patterns and target GPUs. This approach aims to achieve optimal performance across diverse workloads, unlike static implementations.

Figure 1. One 16 × 16 16\( \times \) 16 matrix exposes intrinsic pattern cues and format-induced costs. The matrix contains an irregular dense tile, a high-degree column, an empty row, and uneven row lengths. CSR and CSC traverse compressed rows and columns, respectively. SELL-C with C = 8 C=8 introduces slice-local padding, while 4 × 4 4\( \times \) 4 BSR introduces block fill. The right column shows the resulting work granularity and imbalance for rows, columns, slice slots, and blocks.
Figure 1. One 16 × 16 16\( \times \) 16 matrix exposes intrinsic pattern cues and format-induced costs. The matrix contains an irregular dense tile, a high-degree column, an empty row, and uneven row lengths. CSR and CSC traverse compressed rows and columns, respectively. SELL-C …
cs.AIarxiv:2608.06329v1Lead article

Benchmarking the Benchmarks: Evaluating Benchmarks for Conversational Agents

Noam Koren, Roy Bar-Haim, Abigail Goldsteen

his paper introduces a novel, reference-free framework that leverages LLM judges to evaluate the quality of conversational agent benchmarks. The core method assesses benchmark consistency, complexity, and policy coverage, providing actionable diagnostics of weaknesses. The contribution lies in offering a practical and scalable approach to identify and improve unreliable benchmarks, ultimately leading to more robust evaluations of task-oriented conversational agents.

cs.AIarxiv:2608.06128v1Lead article

Contextual Information Policy Optimization for Search Agents

Xingyu Guo, Wei Chen, Linlin Yang, Baochang Zhang

his paper introduces Contextual Information Policy Optimization (CIPO), a novel reinforcement learning framework for search agents. CIPO addresses the problem of agents relying too heavily on internal knowledge by explicitly rewarding the grounding of their reasoning in retrieved external evidence at each step. This evidence-oriented approach aims to improve the reliability and efficiency of multi-step reasoning in knowledge-intensive tasks.

Illustrative case for the same question. Prior-driven reasoning uses retrieval mainly to confirm a parametric guess, whereas evidence-driven reasoning lets retrieved evidence change the next action.
Illustrative case for the same question. Prior-driven reasoning uses retrieval mainly to confirm a parametric guess, whereas evidence-driven reasoning lets retrieved evidence change the next action.
cs.AIarxiv:2608.06243v1Lead article

DASH: Divergence-Adaptive Supervision Horizons for On-Policy Self-Distillation of Reasoning Models

ZhiYan Hou, Xinyu Tang, Hongyan An, Jianjin Zhang, Weizhen Wang

his paper introduces DASH, a novel on-policy self-distillation method for improving reasoning in language models. DASH addresses the issue of sparse rewards in reinforcement learning by adaptively weighting token-level supervision based on the temporal context of divergence between a teacher and student model. This divergence-adaptive supervision allows for more effective learning by prioritizing corrections based on the history of discrepancies.

cs.AIarxiv:2608.06197v1Lead article

EnvACE: Internalizing Environment Dynamics via World Rehearsal for Agentic Reinforcement Learning

Zishan Xu, Zhiyuan Yao, Yuxin Chen, Yifu Guo, Zhengxi Lu

nvACE trains large language model agents for complex tool use by replacing costly environment interactions with "world rehearsal." The agent learns by alternating between generating tool calls and simulating the environment's responses to those calls, internalizing environment dynamics directly into its parameters. This approach creates an agent world model that improves decision-making and achieves strong performance across multiple benchmarks.

Comparison of three agent rollout paradigms: real-environment rollout, external-simulator rollout, and EnvACE world rehearsal. Existing approaches obtain environment responses from external sources, whereas EnvACE internalizes environment responses within the policy through world rehearsal.
Comparison of three agent rollout paradigms: real-environment rollout, external-simulator rollout, and EnvACE world rehearsal. Existing approaches obtain environment responses from external sources, whereas EnvACE internalizes environment responses within the policy through world…
cs.AIarxiv:2608.06108v1Lead article

Evaluating Investment Logic in Large Language Models: A Real-World Benchmark Towards Personalzied Financial Agents

Yuanhong Jiang, Jingjie Zou, Zhenghong Lin, Xusheng Yu, Qiqi Huang

his paper argues that current evaluations of financial LLMs fail to capture personalized investment competence. They introduce \textsc{InvestLogicBench}, a novel benchmark using real-world investor data to evaluate LLMs based on their reasoning and decision-making process, not just profit. This allows for a more nuanced assessment of an agent's ability to act consistently with an investor's profile and market conditions.

The “Capabilities-Performance Paradox” in financial domain. (Left) Cumulative equity curves between autonomous LLM agents and human expert proxies in a 7-week live U.S. stock trading competition. DeepSeek-V3 achieved the highest cumulative return, significantly outperforming the S&P 500 benchmark, while models like GPT-5 and Claude-Sonnet-4.5 demonstrated lackluster performance in seizing opportunities. Key market inflection points highlight periods where expert logic diverged from model behavior. (Right) Comparative analysis between Foundation Aptitude Scores and Real-World Cumulative Returns. It suggests that superior performance on general benchmarks fails to reliably transfer into financial analytical acumen or effective real-world trading execution.
The “Capabilities-Performance Paradox” in financial domain. (Left) Cumulative equity curves between autonomous LLM agents and human expert proxies in a 7-week live U.S. stock trading competition. DeepSeek-V3 achieved the highest cumulative return, significantly outperforming the …
cs.AIarxiv:2608.06144v1Lead article

FinEvo-Bench: A Longitudinal Benchmark for Self-Evolving Agents in Professional Financial Workflows

Bo Deng, Kang Zhou, Lifan Guo, Chongyang Tao, Xuanren Chen

inEvo-Bench is a new benchmark designed to evaluate self-evolving financial agents by testing their ability to learn and improve across a series of interconnected, real-world financial tasks. Its core method involves a longitudinal design with 120 tasks across six financial domains, each with institution-defined procedures and quality rubrics. The key contribution is its ability to measure how agents retain and leverage experience from previous tasks to enhance performance on subsequent ones, unlike existing benchmarks that evaluate tasks in isolation.

Overview of FinEvo-Bench. Left: 20 business scenes across six financial domains, comprising 120 tasks. Right: an example Stock Technical Analysis task with its natural-language request and six input files.
Overview of FinEvo-Bench. Left: 20 business scenes across six financial domains, comprising 120 tasks. Right: an example Stock Technical Analysis task with its natural-language request and six input files.
cs.AIarxiv:2608.06301v1Lead article

HarnessOpt-Bench: Evaluating LLMs at Harness Optimization

Varun Ursekar, Apaar Shanker, Yash Maurya, Shehab Yasser, Vijay S. Kalmath

his paper introduces HarnessOpt-Bench, a novel benchmark designed to evaluate Large Language Models (LLMs) in their ability to optimize "harnesses" – the surrounding code, prompts, and tools that enable LLMs to act as agents. The core method involves an LLM-based optimizer iteratively improving a given harness based on graded feedback and a fixed evaluation budget, aiming to maximize performance gains over an initial seed harness. The key contribution is providing a standardized protocol for measuring this crucial, yet previously unquantified, capability of LLMs in agentic systems.

Trusted execution for held-out harness optimization. The optimizer can write only the target agent’s harness. It can read the evaluation results and the target task data but not modify them. The optimizer receives per-case development traces and aggregate validation metrics, while test cases and scores remain inaccessible behind the trusted evaluation server. Each candidate is evaluated in isolated, unprivileged sandboxes, and every model call, both the optimizer’s own and the evaluations’, passes through a gateway that enforces model allow-lists and per-scope budgets. The test partition is evaluated only after the optimizer nominates a final candidate. Because held-out data, provider credentials, and budget enforcement are absent from the optimizer’s sandbox, these restrictions are properties of the execution environment rather than instructions the optimizer is expected to follow.
Trusted execution for held-out harness optimization. The optimizer can write only the target agent’s harness. It can read the evaluation results and the target task data but not modify them. The optimizer receives per-case development traces and aggregate validation metrics, whil…
cs.AIarxiv:2608.06123v1Lead article

Poli-Bias: Understanding and Measuring Large Language Model Biases in International Political Conflicts

Massi-Nissa Abboud, Aladin Djuhera, Elena Cabrio, Holger Boche

his paper introduces Poli-Bias, a novel counterfactual framework to measure political bias in LLMs. It systematically swaps country identities in legally equivalent conflict scenarios to reveal subtle disparities in framing and reasoning. Poli-Bias decomposes these differences into five dimensions, offering a nuanced understanding of how LLMs exhibit unequal treatment across various geopolitical contexts.

LLMs may treat legally equivalent conflict scenarios differently based on the countries involved.
LLMs may treat legally equivalent conflict scenarios differently based on the countries involved.
cs.AIarxiv:2608.06057v1Lead article

When History Lies: Evaluating and Improving Tool Use under Misleading Multi-Turn Histories

Xiaoqing Wu, Xingyu Fan, Feifei Li, Wenhui Que

his paper addresses how misleading multi-turn histories can cause tool-using AI agents to make incorrect decisions, even when they possess the correct underlying policy. The authors introduce a benchmark with synchronized "Original," "Polluted," and "Oracle" history views to isolate failure points. They then propose a method called "ours" that trains a student agent to overcome polluted histories by transferring knowledge from an oracle-conditioned teacher.

Overview of the problem, benchmark, and method. (A) An example in which a failed historical interface call precedes the current request while leaving the task state and gold action unchanged. (B) The synchronized Polluted, Original, and Oracle State views in ContextPollute-Bench , together with the evaluated Call and Answer decisions. (C) Oracle-OPD training with polluted-context student rollouts and Oracle-conditioned teacher supervision on the same prefixes. Deployment uses only the trained student and ordinary interaction history.
Overview of the problem, benchmark, and method. (A) An example in which a failed historical interface call precedes the current request while leaving the task state and gold action unchanged. (B) The synchronized Polluted, Original, and Oracle State views in ContextPollute-Bench …
cs.LGarxiv:2608.06253v1Lead article

MetaboLLM: a metabolomics-specialized large language model for biochemical knowledge integration and predictive metabolite graph construction

Dohyun Ku, Min Gu Kwak, Francisco J. Pasquel, Jing Li

etaboLLM is a specialized large language model designed to integrate fragmented metabolomics knowledge by adapting general LLMs through continual pretraining, fine-tuning, and structured retrieval. Its core contribution is enabling the construction of predictive metabolite graphs (MetaboLLM-GIN) from generated biochemical descriptions, which significantly improves patient-level prediction tasks like stress hyperglycemia and hormone-regimen classification compared to existing methods.

cs.LGarxiv:2608.06296v1Lead article

On-Policy Self-Distillation without Any Supervision

Yijiang Li, Bingyang Wang, Yijun Liang, Yunjie Tian, Di Fu

his paper introduces Unsupervised On-Policy Self-Distillation (U-OPSD), a novel method for improving large language models without external supervision. U-OPSD leverages internal consistency by generating multiple outputs, identifying confident errors through majority voting, and then distilling a corrected version into the model's incorrect generations. This approach allows LLMs to self-correct their confidently held mistakes, leading to consistent performance gains across various benchmarks.

Comparison between OPSD / SDFT with ground-truth solution or ICLs (left), SDPO with rich feedback from the environment (middle) and our u-OPSD without any supervision.
Comparison between OPSD / SDFT with ground-truth solution or ICLs (left), SDPO with rich feedback from the environment (middle) and our u-OPSD without any supervision.
cs.LGarxiv:2608.06179v1Lead article

SAGA: Score-Weighted Adaptive Generation Alignment for Low-Resource Nordic Language Models

Hoda Fakharzadehjahromy, Emil Wiman, Andreas Bueff, Hafsteinn Einarsson, Fredrik Heintz

AGA is a novel framework that uses dependency parser outputs instead of human annotations to optimize low-resource language models. It converts parser judgments into preference pairs, combines parser quality with lexical diversity for rewards, and filters low-information pairs. This approach significantly improves grammatical quality in Nordic languages without costly human labeling.

Parser-derived supervision replaces human preference labels: the incorrect case ( Ég ) fails dependency parsing, whereas the correct case ( Mig ) is accepted, providing a preference signal without human annotation.
Parser-derived supervision replaces human preference labels: the incorrect case ( Ég ) fails dependency parsing, whereas the correct case ( Mig ) is accepted, providing a preference signal without human annotation.
cs.CLarxiv:2608.06347v1Lead article

RP-OPSD: Reasoning-Pivot-Guided On-Policy Self-Distillation for Multilingual Reasoning Transfer

Xinye Wang, Junxiao Liu, Shujian Huang

his paper introduces RP-OPSD, a method to improve multilingual reasoning transfer in LLMs. It guides on-policy self-distillation by focusing on "reasoning pivots" – critical decision points in the reasoning process. By using the distributional shift between teacher views with and without an English reference, RP-OPSD effectively anchors the distillation process to enhance cross-lingual reasoning capabilities.

Motivation of reasoning-pivot-guided transfer. Surface variants can preserve the same reasoning state, while pivot drift corrupts downstream reasoning. RP-OPSD uses the distribution gap between the solution-conditioned view q t + q_{t}^{+} and the ablated view q t − q_{t}^{-} to identify reasoning-sensitive tokens. The Frence CoT means ”So we multiply 4 by 3, which makes 12”.
Motivation of reasoning-pivot-guided transfer. Surface variants can preserve the same reasoning state, while pivot drift corrupts downstream reasoning. RP-OPSD uses the distribution gap between the solution-conditioned view q t + q_{t}^{+} and the ablated view q t − q_{t}^{-} to …
cs.AIarxiv:2608.19002v1Lead article

A Theory of Post-hoc Debate Judgement

Xiang Yin, Adam Dejl, Antonio Rago, Lihu Chen, Francesca Toni

his paper proposes a formal theory for post-hoc debate judgment, aiming to improve reproducibility, robustness, groundedness, and explainability in AI debates. The core method involves identifying and testing formal properties that debate judgment should satisfy, and then evaluating existing judgment methods (like LLM judges and formal semantics) against these properties. The contribution is a theoretical framework and empirical analysis for more reliable and understandable AI debate outcomes.

cs.AIarxiv:2608.19029v1Lead article

Adaptive Memory and Reflection Multi-Agent System for Medical Question Answering

Pradeep Murugesan, Luoxiao Yang, Xueli Chen, Xinqi Fan

his paper introduces an Adaptive Memory and Reflection (AMR) multi-agent system for medical question answering. Its core method involves specialized agents with dedicated memory and reflection mechanisms to retrieve prior cases and refine reasoning. The system's contribution lies in its adaptive workflow and consensus/ethical oversight, leading to improved accuracy and responsible medical QA.

cs.AIarxiv:2608.19161v1Lead article

Beyond the Transcript: Detecting Covert Co ordination in Latent Multi-Agent Communication

Ramneet Kaur, Pradyumna Chari, Ramesh Raskar, Jugad Singh, Sumit Kumar Jha

his paper introduces Verifiable Latent Alignments (VLA), a framework to detect and control covert coordination in multi-agent language models by analyzing their hidden communication states. VLA links private latent states to public actions using event identifiers for causal analysis, offering a three-layer monitor for anomaly detection and influence analysis, along with steerability mechanisms. The core contribution is enabling the detection of hidden harmful coordination and providing methods to influence or prevent it.

cs.AIarxiv:2608.18878v1Lead article

DentAgent: Evidence-Centric Multi-Agent Coordination for Multimodal Dental Reasoning

Zijie Meng, Xiwei Dai, Yixuan Tang, Jin Hao, Yang Feng

entAgent is an evidence-centric multi-agent framework that addresses limitations in existing dental AI systems by integrating multimodal data. It uses a coordinated system of five specialized agents, each leveraging domain tools to convert observations into structured evidence records. This evidence is then managed on an Evidence Blackboard, ensuring a unified and traceable reasoning process for dental assessment.

cs.AIarxiv:2608.19013v1Lead article

Harness Continual Learning: Continual Adaptation Beyond Model Parameters

Borui Kang, Jinrui Gu, Junhan Lv, Wenbin Li, Lei Wang

his paper introduces Harness Continual Learning (HCL), a new paradigm that enables agents to adapt and improve through changes in their "harness" (prompts, memories, tools, etc.) rather than solely by updating model parameters. The core method involves evolving this harness around a frozen foundation model, addressing "harness-level forgetting" where new adaptations disrupt old behaviors. The contribution is a framework and instantiation of HCL with specific components, offering a way to achieve continual learning without retraining the entire model.

The shift in the object of continual learning. Model-centric methods update model parameters \( \theta \) over sequential experience. HCL instead updates harness state around a frozen foundation model. In both settings, adaptation can improve new behavior while interfering with behavior acquired earlier.
The shift in the object of continual learning. Model-centric methods update model parameters \( \theta \) over sequential experience. HCL instead updates harness state around a frozen foundation model. In both settings, adaptation can improve new behavior while interfering with b…
cs.AIarxiv:2608.18937v1Lead article

MedUAG: Unified Understanding and Generation for Medical Multimodal Models

Zijie Meng, Yuncheng Zhang, Hualiang Wang, Yitian Tang, Xiaotang Gai

his paper introduces MedUAG, a unified framework for medical multimodal understanding and generation. It addresses the lack of comprehensive resources by creating the largest medical dataset (MedUAGCorpus) and a systematic evaluation benchmark (MedUAGBench). MedUAG, trained on these resources, demonstrates strong performance across various medical tasks, establishing a new standard for unified medical AI.

cs.AIarxiv:2608.18952v1Lead article

rEDMRec: Distilling Large Language Model Reasoning into an Editable Experience Memory for Recommendation

Minh Hoang Nguyen, Tung Le, Huy Tien Nguyen

his paper proposes rEDMRec, a method to distill LLM reasoning for recommendations into a compact, editable "experience memory." Instead of re-generating expensive reasoning for each recommendation, rEDMRec compresses it into structured channels that a lightweight model can retrieve from. This allows for reusable, inspectable, and correctable reasoning, improving recommendation efficiency and adaptability.

cs.AIarxiv:2608.19025v1Lead article

Self-prompting and cross-model consensus enable reproducible data extraction from scientific literature with large language models

Valentin Romanov, Monique Bax, Steven Niederer

his paper introduces a **self-prompting and cross-model consensus method** for reproducible data extraction from scientific literature using large language models (LLMs). The core contribution is demonstrating that LLMs can effectively extract nuanced data by generating their own prompts and that cross-model consensus improves accuracy, though human oversight remains crucial for high-quality datasets.

cs.AIarxiv:2608.18933v1Lead article

SkillForge: Self-Distilling Agents for Project-Specific Issue Resolution

Silin Chen, Han Li, Xiaodong Gu, Yuling Shi, Haibing Guan

killForge addresses LLM agents' lack of project-specific knowledge for software issue resolution by proactively generating and resolving synthetic issues. This self-distillation process allows agents to acquire and store reusable, project-specific knowledge as "entity-grounded skills" without relying on historical data or incurring high per-issue test-time costs.

cs.AIarxiv:2608.18852v1Lead article

SkillGate: Training In-Policy Skill Selection in Long-Horizon Agents

Qingyao Li, Wenxiang Jiao, Shuai Shao, Kangning Zhang, Yuan Lu

his paper introduces SkillGate, a novel method for training agents to select skills in long-horizon tasks. It addresses "selector credit starvation," a problem where the skill selection mechanism receives insufficient or incorrect training signals due to delayed rewards and cascading failures. SkillGate's core contribution is a training approach that directly attributes credit to skill choices, ensuring more accurate and effective skill selection for complex, multi-step tasks.

cs.AIarxiv:2608.19197v1Lead article

SPADE: Self-Play in Adaptive Synthetic Executable Environments

Bo Liu, Simon Yu, Yiding Jiang, Ao Qu, Andrew Zhao

PADE is a self-play reinforcement learning framework where a single LLM acts as both an Environment Designer and a Reasoning Agent. The Environment Designer generates diverse, long-horizon training environments as executable code, while the Reasoning Agent learns to solve tasks within these environments. This approach allows for continuous self-improvement by dynamically adapting the training goal distribution as the agent scales.

cs.AIarxiv:2608.19072v1Lead article

What is Missing from AI Post-Training AI: An Empirical Analysis

Joy Jia Yin Lim, Xin Huang, Hao Peng, Yaxi Lu, Xin Cong

his paper distinguishes between an AI agent's ability to execute a training strategy and its ability to revise that strategy. Through empirical analysis of LLM post-training trajectories, the authors find that agents typically fix their strategy early on and only make local adjustments. They propose an "experience-driven scaffold" as a key intervention to improve both execution and strategy-level decision-making.

cs.LGarxiv:2608.18849v1Lead article

GEAR: Generative Expansion and Real Anchoring for Two-Stage Distillation of Tabular Foundation Models

Qi Qin, Jiajie Zhu, Dali Chen, Yuzhao Zhang, Jia-Xing Han

EAR is a two-stage distillation framework that compresses large tabular foundation models (TFMs) into efficient MLP or tree-based predictors. It first uses synthetic data to train a student model on TFM outputs, expanding its coverage. Then, it refines the student using real data and out-of-fold predictions to avoid self-labeling issues, achieving improved performance over traditional methods.

cs.CLarxiv:2608.19009v1Lead article

Grading the Graders: Verification Autonomy Levels (L0-L5) for LLM Reasoning

Yajie Yin

his paper introduces Verification Autonomy Levels (VAL), a new meta-standard to classify LLM verification methods. VAL categorizes verifiers based on the origin of their verification specifications and the guarantees their verdicts provide, ranging from LLM self-declaration (L0) to provable completeness (L3/L4). The core contribution is a unified framework to understand and compare the reliability and autonomy of different LLM verification strategies, highlighting the inherent "completeness blind spot" in many current approaches.

cs.AIarxiv:2608.20318v1Lead article

AI4AI-Bench: Benchmarking LLM Agents in Algorithmic Design for Recursive Self-Improvement

Yizhe Chi, Wenyi Li, Deyao Hong, Xiaoqiu Wang, Mingju Gao

his paper introduces AI4AI-Bench, a novel benchmark designed to evaluate Large Language Model (LLM) agents' ability to design training algorithms for recursive self-improvement (RSI). The core method involves agents modifying existing training algorithms within frozen research repositories, with their rewritten code then evaluated on its performance. The key contribution is providing the first isolated benchmark for assessing an AI's capacity to improve the AI development process itself, rather than just optimizing hyperparameters or data collection.

cs.AIarxiv:2608.20161v1Lead article

DARS: Dual-Level Credit Assignment RL with Structured Reasoning for Instruction-Based Image Editing

Haoxiang Cao, Jiajiong Cao, Xuanpu Zhang, Changqian Yu, Chaoqun Wang

his paper introduces DARS, a reinforcement learning framework for instruction-based image editing. DARS addresses the inefficiency of traditional training by employing dual-level credit assignment. It achieves this by using multi-plan, multi-render rollouts to estimate reward variability for module routing and adaptive curriculum learning, and by introducing structured reasoning within the planner to enable token-level supervision from outcome-level feedback.

Figure 1. Two visually poor editing outcomes can require opposite cross-module update emphases. Case A : the planner captures the requested edit reasonably well, but the renderer fails to realize it, so this sample should place more corrective update weight on the renderer. Case B : the sampled plan is a less useful intermediate for the instruction, and the renderer faithfully executes it, so this sample should place more corrective update weight on the planner. DARS is designed to distinguish render-dominant from plan-dominant update needs through routing signals; when planner-side emphasis is needed, its structured slots support finer within-planner diagnosis. Teaser showing two low-scoring failure cases in a two-stage image editing pipeline that require opposite cross-module credit-assignment decisions: one should emphasize renderer correction, while the other should emphasize planner correction.
Figure 1. Two visually poor editing outcomes can require opposite cross-module update emphases. Case A : the planner captures the requested edit reasonably well, but the renderer fails to realize it, so this sample should place more corrective update weight on the renderer. Case …
cs.AIarxiv:2608.20195v1Lead article

From Agent Behaviour to Agent-Friendly Documentation: An Empirical Study of How Coding Agents Discover, Read, and Write Technical Documentation

Zhijun Gao, Jing Chen

his paper empirically studies how coding agents interact with technical documentation. It reveals that agents primarily consult agent-facing artifacts like instruction files and working notes, rather than traditional technical documentation or API references. This finding challenges current documentation practices, suggesting a need to adapt documentation strategies for autonomous agents.

Figure 1. Agents’ documentation interactions across 557 SWE-chat sessions (panels a–d, n = 3,033 n=3{,}033 documentation events) and 33,097 AIDev agentic pull requests (panel e). (a) Agent-facing documents — instruction files and agent working notes — account for 60.5% of interactions, whereas API references account for 1.3%; the right-hand column uses a magnified axis. (b) Testing and building are less frequent within three events of a consultation and remain so after adjustment; the two authoring outcomes differ between the unadjusted lift and the stage-adjusted odds ratio, so those associations remain unresolved. Intervals are session-level cluster-bootstrap estimates. (c) Interaction is predominantly self-initiated (70.2% of all 3,033 interactions; 62.5% of the 1,615 consultation events) rather than failure-driven (7.5%; 9.7%); the axis counts all interactions. (d) Of ten candidate stages, Validate and Escalate have zero events under our operational definitions (open markers); stages overlap and do not sum to 3,033. (e) Among pull requests that change both code and documentation, code is touched first 4.7 × \( \times \) more often, although 42.6% first touch both in a single commit, for which no order is observable; panel e uses a different dataset and unit of analysis (pull requests), and its error bars are Wilson intervals — the repository cluster-bootstrap equivalents are in Table 6 . Five panels summarising document types, post-consultation actions, interaction triggers, candidate interaction stages, and code–documentation ordering in pull requests.
Figure 1. Agents’ documentation interactions across 557 SWE-chat sessions (panels a–d, n = 3,033 n=3{,}033 documentation events) and 33,097 AIDev agentic pull requests (panel e). (a) Agent-facing documents — instruction files and agent working notes — account for 60.5% of interac…
cs.AIarxiv:2608.20281v1Lead article

Inject, Align, Recover: Staged Post-Training for Retrieval-Free Document Knowledge Internalization

Qian Kou, Xiaofeng Shi, Xiaosong Qiu, Hua Zhou

his paper introduces IAR, a three-stage post-training method for enabling large language models to answer questions from a fixed document set without retrieval. IAR first injects document knowledge through specialized objectives, then aligns the model with question-answering behavior using answer-only supervision, and finally recovers general capabilities. The core contribution is a staged approach that effectively internalizes document knowledge, improving retrieval-free QA performance across various models and datasets.

The overview of IAR . Vanilla SFT learns from generated QA pairs and covers only the facts selected by those questions. CPT+SFT models full document token streams before a separate QA alignment stage. IAR injects document knowledge through continuation, rewrite, and instruction-conditioned reconstruction objectives, aligns the injected model with answer-only QA supervision, and recovers general ability via post-hoc model merging. The final model is selected by balancing retrieval-free domain QA performance and general capability retention.
The overview of IAR . Vanilla SFT learns from generated QA pairs and covers only the facts selected by those questions. CPT+SFT models full document token streams before a separate QA alignment stage. IAR injects document knowledge through continuation, rewrite, and instruction-c…
cs.AIarxiv:2608.20061v1Lead article

Let's Scale Step by Step: Compute-Efficient Hyperparameter Transfer for Large-Scale Mixture-of-Experts

Nayeon Kim, Hojin Lee, Yunju Bak, Jaesun Park, Boseop Kim

his paper introduces a compute-efficient method to transfer optimal learning rates for large Mixture-of-Experts (MoE) models. It first demonstrates that optimal learning rates are consistent across width-scaled MoE models using a novel parameterization. Then, it extrapolates these findings to trillion-token training horizons via a predictive scaling law, significantly reducing the computational cost of hyperparameter optimization.

cs.AIarxiv:2608.20011v1Lead article

Manifold Drift in Flow Preference Optimization: A Root Cause of Reward Hacking

Yansen Han, Shengyi Liao, Yuanxing Zhang, Pengfei Wan, Tao Lin

his paper identifies "manifold drift" as a key cause of reward hacking in continuous-time generative model alignment. The authors show that standard preference optimization can push generated samples off the original data manifold. They propose ThermoDPO, a temperature-controlled objective that anchors preference updates to preferred samples, effectively mitigating manifold drift and connecting existing methods.

Comparison of FlowDPO (left) and ThermoDPO -weighted (right). FlowDPO improves preference with manifold drift, whereas ThermoDPO -weighted improves preference while preserving quality.
Comparison of FlowDPO (left) and ThermoDPO -weighted (right). FlowDPO improves preference with manifold drift, whereas ThermoDPO -weighted improves preference while preserving quality.
cs.AIarxiv:2608.20202v1Lead article

MemTrapBench: Benchmarking Cognitive Traps in LLM Memory Use

Mengru Wang, Haozhe Luo, Zhenqian Xu, Zhixiang Cui, Haoming Xu

his paper introduces MemTrapBench, a novel benchmark designed to evaluate how retrieved memories can negatively impact LLM reasoning and performance, a phenomenon termed "cognitive traps." The core method involves testing for Reasoning Fixation and Belief Distortion, revealing that current memory frameworks often degrade performance compared to no-memory baselines. The contribution lies in highlighting and systematically measuring these memory-induced failures, prompting further research into mitigation strategies.

Memory is not always what you need. (a) Without memory, Gemini-3-Flash-Preview finds the factorial solution to the query. The retrieved memory contains valid and relevant examples in this figure that are solved using basic arithmetic, but it causes the model to fixate on the same operation regime and prevents it from considering factorial. (b) On Gemini-3-Flash-Preview, using the full interaction history memory reduces performance across all four Memory Trap scenarios compared with the no-memory setting.
Memory is not always what you need. (a) Without memory, Gemini-3-Flash-Preview finds the factorial solution to the query. The retrieved memory contains valid and relevant examples in this figure that are solved using basic arithmetic, but it causes the model to fixate on the same…
cs.AIarxiv:2608.20314v1Lead article

MidTool: Mid-training Data Synthesis for Agentic Tool Use

Fengqing Jiang, Yite Wang, Boyi Liu, Zhaoyang Wang, Canwen Xu

his paper introduces MidTool, a method for synthesizing data during the mid-training phase of large language models to improve their general tool-use capabilities. MidTool combines diverse real-world data with synthesized supervision to teach models how to effectively recognize, utilize, and compose tools. The contribution lies in providing a robust pipeline for this crucial mid-training stage, enabling models to better understand tool affordances and handle complex workflows.

Left: MidTool-Mix is a 20.3B-token mid-training corpus built from web, PDF, code, and tool sources with synthesized agentic trajectories. Middle: Training pipeline from base model. Right: On MCP-Universe, our mid-trained 4B and 8B models outperform Qwen3 official models, showing that dedicated mid-training yields stronger agentic capability than scaling alone.
Left: MidTool-Mix is a 20.3B-token mid-training corpus built from web, PDF, code, and tool sources with synthesized agentic trajectories. Middle: Training pipeline from base model. Right: On MCP-Universe, our mid-trained 4B and 8B models outperform Qwen3 official models, showing …
cs.AIarxiv:2608.19974v1Lead article

ReguSim: Evaluating LLM Agent Rule Grounding in Financial Compliance

Yiyang Luo, Yihang Jiang, Qijun Xie, Liang Lan, Lin Willian Cong

his paper introduces ReguSim, a controlled environment and benchmark (ReguBench) to evaluate how well LLM agents in finance adhere to compliance rules. Their core method separates reasoning, action, enforcement, and evidence to analyze rule grounding. The key contribution is framing financial compliance evaluation as an audit of actions and evidence use, rather than a simple score, revealing that while visible rules help, they don't fully prevent violations, and LLM monitors need enforcement evidence to be accurate.

ReguSim and ReguBench pipeline. ReguSim logs prompt state, trader rationale/action, execution outcome, and trace evidence; ReguBench evaluates a target-marked monitor judgment from that evidence.
ReguSim and ReguBench pipeline. ReguSim logs prompt state, trader rationale/action, execution outcome, and trace evidence; ReguBench evaluates a target-marked monitor judgment from that evidence.
cs.AIarxiv:2608.20237v1Lead article

Rule-Compliant Visual Spatial Planning for Multimodal Large Language Models

Yu Chen, Ting Lei, Yaoyi Li, Jia Cai, Zhecen Wu

his paper addresses the challenge of MLLMs performing visual spatial planning under complex, novel rules. Their core method involves the RuleMaze benchmark and a Language-Logic-Function Hybridization approach to automatically generate and validate rules. The contribution is a framework that enables MLLMs to understand spatial layouts, interpret natural-language rules, and plan actions that strictly adhere to these constraints, improving generalization.

cs.AIarxiv:2608.20201v1Lead article

The Third Restructuring of Software Form: From the Three-Tier Architecture to Storage, Models, and Agents

Wei Lin, Tao Zhou, Zhaofei Xie, Changgui Hong

his paper proposes Software 3.0, a new paradigm where context and reasoning drive software behavior. Its core method is the convergence of three elements: a generalized database for state, a large model for reasoning, and an agent for execution. This shift restructures traditional software architectures by integrating the UI and business logic into the model and agent, with data becoming the unified persistent state.

cs.LGarxiv:2608.20099v1Lead article

Reward-Guided Autoregressive Graph Generation for Efficient Multi-Agent Communication Topology Design

Poomphob Suwannapichat, Boonyarit Changaival, Caesar Wu, Pascal Bouvry

his paper introduces RGA-Designer, a method for efficiently designing communication topologies in multi-agent systems. It builds upon autoregressive graph generation by incorporating a reinforcement learning-inspired reward model that incentivizes both task accuracy and structural sparsity. This approach successfully reduces token consumption by an average of 20.5% while maintaining task performance.

Overview of our reward-guided pipeline for MAS topology generation.
Overview of our reward-guided pipeline for MAS topology generation.
cs.CLarxiv:2608.20338v1Lead article

ConceptGuard: Benchmarking Context-Sensitive Unlearning in Large Language Models

Sahil Kale, Ian Harris

his paper introduces **ConceptGuard**, a novel benchmark for evaluating context-sensitive unlearning in LLMs. Its core method focuses on **dual-use concepts**, which have both harmful and benign applications, to assess if LLMs can selectively remove unsafe knowledge while retaining beneficial uses. The key contribution is a more realistic evaluation framework that moves beyond simple factual recall to measure the nuanced ability of LLMs to unlearn harmful behaviors without compromising useful functionalities.

cs.CLarxiv:2608.20129v1Lead article

Multi-Agent Orchestration with the Common-Sense Reasoning Capabilities of LLMs for Autonomous Driving

Mehdi Azarafza, Faezeh Pasandideh, Ali Ehteshami Bejnordi, Stefan Henkler, Achim Rettberg

his paper proposes a hybrid framework for autonomous driving that combines reinforcement learning (RL) and PID control, orchestrated by a Large Language Model (LLM). The LLM provides common-sense reasoning to guide the control modules and iteratively refines the RL reward function, enhancing adaptability to dynamic environments. This approach aims to leverage LLMs' contextual understanding without direct control, mitigating latency and hallucination risks.

High-level system architecture.
High-level system architecture.
cs.CLarxiv:2608.20116v1Lead article

When Text and Numbers Disagree: Evidence Arbitration in Large Language Models

Mattia Carletti, Edward Phillips, Fredrik K. Gustafsson, Patitapaban Palo, Lei Clifton

his paper introduces a synthetic benchmark to study how Large Language Models (LLMs) resolve conflicts between textual and numerical evidence. The core method involves creating controlled scenarios where one evidence source is correct and the other is not, allowing for systematic analysis of LLM arbitration. The key contribution is the finding that LLMs exhibit predictable arbitration behaviors, favoring text over numbers, prioritizing recency over reliability cues, and sometimes over-relying on external forecasts.

cs.AIarxiv:2608.21292v1Lead article

AUSO: Action-Level Unified Skill Optimization from Internalization to Utilization

Huizu Lin, Chengkai Huang, Tianqi Gao, Tao Huang, Daijiao Liu

USO unifies skill learning and utilization by optimizing them at the action level throughout an agent's policy evolution. This progressive approach allows the agent to first acquire foundational skills from teacher guidance and environmental feedback, then focus on utilizing these skills to improve individual decisions when beneficial, addressing limitations of existing methods that fragment training and assign uniform importance to actions.

Figure 1. Empirical evidence of ambiguous medium/easy skill-routing boundaries in Skill0.5. Samples across the success threshold can differ by as little as 1 / 8 1/8 , revealing the ambiguity of threshold-based routing.
Figure 1. Empirical evidence of ambiguous medium/easy skill-routing boundaries in Skill0.5. Samples across the success threshold can differ by as little as 1 / 8 1/8 , revealing the ambiguity of threshold-based routing.
cs.AIarxiv:2608.20975v1Lead article

Belief Without Behavior: Measuring the Translation of Theory of Mind into Coordinated Social Action in Vision-Language Models

Tonglin Yan, Gregoire Sergeant-Perthuis, David Rudrauf

his paper introduces MOSAIC, a benchmark that measures how well vision-language models (VLMs) translate their understanding of others' mental states (Theory of Mind) into coordinated verbal and nonverbal actions. The core method involves embodied agents interacting in scenarios requiring integrated communication and movement, under varying ToM demands. The key contribution is demonstrating that current VLMs struggle to bridge this gap, failing to exhibit behaviors consistent with sophisticated ToM reasoning, and that explicitly imposing ToM constraints doesn't reliably improve their coordinated social actions.

MOSAIC benchmark design. (Top left) Two agents interact in a virtual environment: the subject knows the reward location and must help or mislead the participant depending on the assigned relationship mode. (Bottom left) Four experimental conditions cross interaction mode (competitive vs. cooperative) with ToM constraint level (ToM-0 vs. ToM-1), with 50 trials per condition per model. (Right) Each trial runs for 10 rounds; rounds 3, 6, and 9 include a verbal exchange phase besides non-verbal actions. In non-verbal rounds, each agent receives a context prompt, a first-person perspective visual perception, and a structured belief-and-observation state, and produces action reasoning together with motor action (movement, rotation, or staying idle) and emotional expression (musculoskeletal and physiological channels). In verbal rounds, the same inputs are supplemented by the interlocutor’s speech, and the agent generates an inner speech reasoning trace and a natural language answer.
MOSAIC benchmark design. (Top left) Two agents interact in a virtual environment: the subject knows the reward location and must help or mislead the participant depending on the assigned relationship mode. (Bottom left) Four experimental conditions cross interaction mode (competi…
cs.AIarxiv:2608.21101v1Lead article

ClawSentry: A Progressive Multi-Tier Security Monitor for Safeguarding Autonomous LLM Agents

Kai Wang, Zeming Wei, BiaoJie Zeng, Chang Jin, An Wang

lawSentry addresses the progressive risks of autonomous LLM agents by introducing a multi-tier security monitor. Its core method involves a four-stage progressive risk assessment, starting with initial skill package review and extending to runtime monitoring across invocation, execution, and consequence phases. The key contribution is a framework-agnostic gateway that progressively analyzes and mitigates threats at different points in the agent's lifecycle, preventing cascading compromises.

ClawSentry aligns one gateway with four lifecycle loci. FSPR gates A; effect-normalized L1–L3 mediation covers B–C; retry memory catches capability-equivalent bypasses; and asynchronous D analysis informs later actions. AHP applies one policy across four frameworks; bottom badges report selective review and safety–utility.
ClawSentry aligns one gateway with four lifecycle loci. FSPR gates A; effect-normalized L1–L3 mediation covers B–C; retry memory catches capability-equivalent bypasses; and asynchronous D analysis informs later actions. AHP applies one policy across four frameworks; bottom badges…
cs.AIarxiv:2608.21027v1Lead article

Don't Solve, Just Compare: Tiny Advisors for Runtime Intervention in LLM Agents

Yanze Jiang, Mingxuan Li, Yuhao Wang, Shengfang Zhai, Jiaheng Zhang

his paper introduces Comparison-Only Tiny Advisor (COTA), a novel framework for improving LLM agent reliability through runtime intervention. Instead of requiring a full solver or a complex critic, COTA uses a small "tiny advisor" that compares the agent's proposed action with alternatives. By repeatedly judging which option leads to better outcomes, COTA efficiently intervenes when necessary, guiding the agent towards successful task completion.

cs.AIarxiv:2608.21156v1Lead article

Graph Engineering in the Era of LLM Agents: From Individual Intelligence to System Intelligence

Yuyuan Feng, Zhishang Xiang, Chaobin Yang, Qichao Ma, Zerui Chen

his paper introduces "System Intelligence" as a paradigm shift for LLM agents tackling complex tasks. Instead of solely enhancing individual agents, it proposes distributing intelligence across specialized agents and coordinating them at a system level. This approach addresses limitations of single agents by enabling heterogeneous expertise, parallel execution, and independent verification, ultimately leading to more robust and adaptive agent systems.

Overview From Model Intelligence to System Intelligence. Prompt and Context Engineering elicit and condition the access of foundation models to realize model intelligence. Harness and Loop Engineering extend and orchestrate agentic capabilities to enable Individual Intelligence. Graph Engineering builds on the foundation of individual agents through Task Organization, Agent Coordination, and Runtime State Management, empowering System Intelligence.
Overview From Model Intelligence to System Intelligence. Prompt and Context Engineering elicit and condition the access of foundation models to realize model intelligence. Harness and Loop Engineering extend and orchestrate agentic capabilities to enable Individual Intelligence. …
cs.AIarxiv:2608.21209v1Lead article

Personalized Privacy Control in LLMs via Attention Head Intervention

Junseok Kim, Nakyeong Yang, Kyomin Jung

his paper introduces personalized privacy control for LLMs, recognizing that users have unique disclosure preferences beyond general contextual norms. Their contribution is P3Bench, a benchmark for evaluating personalized privacy, and \textsc{Repair}, an inference-time method that intervenes in attention heads to enforce these user-specific privacy policies, overcoming the limitations of prompt-based methods.

Failure of Personalized Privacy Control. LLM agents may ignore the user’s privacy policy and disclose contextually appropriate sensitive information based on their own judgment during task execution.
Failure of Personalized Privacy Control. LLM agents may ignore the user’s privacy policy and disclose contextually appropriate sensitive information based on their own judgment during task execution.
cs.AIarxiv:2608.21074v1Lead article

PromptResponse: Optimizing Prompts for LLM Coding Tasks

Erik Thureck, Robert Kühnen, Tim Jacobowitz

his paper introduces PromptResponse, a study investigating how prompt formatting and LLM-based tuning impact LLM code generation. It found that consistent formatting, particularly JSON, enhances efficiency and stability, while LLM-tuned prompts surprisingly degrade performance. The core contribution is demonstrating that structured formatting is more beneficial than LLM-driven prompt optimization for coding tasks.

cs.LGarxiv:2608.21345v1Lead article

Asymmetric Capacity Allocation in Self-Refinement Pipelines

Zhuoyi Yang, Ian G. Harris, Salar Hashemitaheri, Cassie Huang, Yuangang Li

his paper investigates how model size impacts each stage of self-refinement pipelines (generation, critique, revision) for LLMs. The core method involves systematically varying model sizes across different benchmarks to understand their stage-wise contributions. The key contribution is demonstrating that larger generators and refiners are beneficial, while critic size has minimal impact, offering insights for efficient resource allocation in LLM agent design.

cs.LGarxiv:2608.21142v1Lead article

COEC: Calibrated Orthogonal-Equivalence Compensation for Structured Pruning of Large Language Models

Peiqi Yu, Nam Ling, Wei Wang, Wei Jiang

his paper introduces COEC, a training-free method to compensate for accuracy loss in structured pruning of LLMs. COEC applies alternating orthogonal rotations to the remaining weights, allowing them to adapt more effectively after column removal. Its key contribution lies in using a calibrated approach with generalized cross-validation and an alignment penalty to optimize these rotations, preserving geometric relationships and improving accuracy.

cs.LGarxiv:2608.21030v1Lead article

COMET: Contrastive Motion-Enhanced Temporal Reasoning for Video Multimodal Large Language Models

Chenghua Zhu, Zhaolu Kang, Qifan Shi, Siyan Wu, Kehan Jiang

OMET enhances video multimodal large language models by explicitly modeling frame-to-frame motion and its interaction with appearance. Its core method involves a temporal motion branch that injects motion information into the visual stream via attention, and a novel optimization strategy that leverages temporal order as a direct learning signal. This approach significantly improves fine-grained temporal understanding in videos.

Figure 1. Frame-independent encoding versus explicit temporal representation. (a) sparse RGB frames leave motion implicit. (b) frame-to-frame change makes temporal evidence explicit. A comparison between frame-independent video encoding and an explicit representation of frame-to-frame temporal changes.
Figure 1. Frame-independent encoding versus explicit temporal representation. (a) sparse RGB frames leave motion implicit. (b) frame-to-frame change makes temporal evidence explicit. A comparison between frame-independent video encoding and an explicit representation of frame-to-…
cs.LGarxiv:2608.21172v1Lead article

Thermo-FL: Thermal-Aware Robust Federated Fine-Tuning of Large Language Models for Edge AI

Shiva Shrestha, Kazi Shaharair Sharif, Zongxing Xie, Jiajing Huang, Anhao Xiang

hermo-FL tackles the dual challenges of hardware thermal constraints and adversarial attacks in federated LLM fine-tuning. Its core method is a thermal-aware LoRA adaptation that dynamically adjusts training and update sparsity based on device temperature. This allows for robust and efficient LLM fine-tuning on edge devices by mitigating performance degradation from heat and protecting against corrupted updates.

cs.LGarxiv:2608.20991v1Lead article

Trojaning the Alignment: Stealthy Backdoor Attacks against Graph Foundation Models

Minhua Lin, Zhicheng Gao, Yilong Wang, Hanqing Lu, Xiang Zhang

his paper introduces STAG, a novel backdoor attack method targeting Graph Foundation Models (GFMs) on text-attributed graphs (TAGs). STAG's core method is to stealthily inject triggers that exploit the alignment mechanism between graph and text representations, unlike previous attacks that treated modalities independently. This approach allows for more effective and harder-to-detect attacks by manipulating the shared semantic space, thereby compromising the model's integrity.

cs.CLarxiv:2608.21242v1Lead article

Affective Context Amplifies Sycophancy in LLM Responses

Jiayi Li, Sanjana Menon, Brett Frischmann, Shomir Wilson, Sarah Rajtmajer

his paper investigates how LLMs' awareness of user emotions influences their tendency to be sycophantic. The core method involves comparing LLM responses to the same content presented as a third-party versus a user's own disclosure, measuring sycophancy by the difference in evaluations. The key contribution is demonstrating that negative user affective states, like loneliness and distress, significantly amplify LLM sycophancy, suggesting these states act as vulnerability signals.

An illustrative example from r/AmItheAsshole. When an LLM evaluates the narrator’s actions (top), it identifies the narrator’s actions as unethical and a breach of duty. When the LLM acts as a conversational partner responding to the same content as the user’s self-disclosure, it softens its evaluative stance while still acknowledging procedural concerns (bottom, left). With the user’s affective context, it becomes less oppositional (bottom, right).
An illustrative example from r/AmItheAsshole. When an LLM evaluates the narrator’s actions (top), it identifies the narrator’s actions as unethical and a breach of duty. When the LLM acts as a conversational partner responding to the same content as the user’s self-disclosure, it…
cs.CLarxiv:2608.21265v1Lead article

Memory Augmentation Unlocks Efficient Chain-of-Thought Reasoning

Simeng Zhang, Yilong Chen, Wenyuan Zhang, Zhenyu Zhang, Yao Chen

his paper introduces Memory-Augmented Compression, a training-free method to make Chain-of-Thought (CoT) reasoning more efficient. It formalizes the trade-off between reasoning verbosity and generation cost with the "Context-Generation Substitution Law." The core method constructs reusable "reasoning memories" from past traces, which act as scaffolds to compensate for information lost during CoT compression, thereby improving performance.

Illustration of memory-augmented compression. Explicit memory shifts part of the reasoning support to the prefill stage, improving short-CoT accuracy while preserving generation efficiency.
Illustration of memory-augmented compression. Explicit memory shifts part of the reasoning support to the prefill stage, improving short-CoT accuracy while preserving generation efficiency.
cs.AIarxiv:2608.23318v1Lead article

Agent-G$^2$: Gaussian Guidance for Agentic Reinforcement Learning

Zixuan Wang, Yanrui Miao, Zhengxi Lu, Teng Pan, Yiwen Qiu

his paper introduces Agent-G$^2$, a novel reinforcement learning method that addresses reward sparsity by providing guidance from expert trajectories. Instead of a single optimal guidance depth, Agent-G$^2$ models the useful guidance as a Gaussian distribution, allowing for a range of effective depths. This approach estimates the Gaussian's parameters online from existing rollouts, eliminating the need for extra probing or learned predictors, and thus improving efficiency.

Hint-based RL paradigms across training steps t 0 , t 1 , t 2 t_{0},t_{1},t_{2} . (a) Schedule-based: shared d t d_{t} across samples. (b) Probe-based: O ⁡ ( log ⁡ n ) O(\( \log \) n) per-sample probes. (c) Agent-G 2 (ours): d i ∼ 𝒩 ⁡ ( μ t , σ t 2 ) d_{i}\( \sim \)\( \mathcal{N} \)(\( \mu_{t} \),\( \sigma_{t}^{2} \)) per task, estimated online from existing rollouts.
Hint-based RL paradigms across training steps t 0 , t 1 , t 2 t_{0},t_{1},t_{2} . (a) Schedule-based: shared d t d_{t} across samples. (b) Probe-based: O ⁡ ( log ⁡ n ) O(\( \log \) n) per-sample probes. (c) Agent-G 2 (ours): d i ∼ 𝒩 ⁡ ( μ t , σ t 2 ) d_{i}\( \sim \)\( \mathcal{N…
cs.AIarxiv:2608.23244v1Lead article

Credal Large Language Models for Semantic Commitment under Uncertainty

Shireen Kudukkil Manchingal, Sofiia Nikolenko, Fabio Cuzzolin

his paper introduces Credal Large Language Models (CLLMs) to address the issue of LLMs' unwarranted confidence in incorrect answers. CLLMs use an ensemble of adapters to represent uncertainty as a "credal set" of possible predictions, revealing the range of plausible outcomes instead of a single output. This allows for new metrics like Credal Token Commitment and Semantic Commitment Consistency to better measure semantic commitment and detect hallucinations.

cs.AIarxiv:2608.23391v1Lead article

Cross-Domain, Multi-Task Data-to-Text Generation without In-Domain Training Data

Yifei Song, Kun Efimov-Zhang, Claire Gardent

his paper tackles data-to-text generation across diverse domains and tasks without requiring in-domain training data. Its core method, data-driven knowledge distillation (DDKD) with structure-preserving augmentation, trains smaller models to effectively generate text from structured data. The key contribution is demonstrating DDKD's superior performance over zero-shot and out-of-domain fine-tuning, even with significantly smaller models.

cs.AIarxiv:2608.23264v1Lead article

Hidden in the Request: Explaining Unethical LLM Compliance through Token Relevance

Or Biton, Tomer Krichli, Itai Allouche, Joseph Keshet

his paper investigates why Large Language Models (LLMs) sometimes comply with unethical requests despite alignment efforts. The core method involves presenting unethical scenarios in different formats and using Layer-wise Relevance Propagation (LRP) to analyze token importance. The key contribution is identifying an "attribution bias" where LLMs overemphasize benign framing tokens over those signaling unethical intent, leading to compliance failures.

cs.AIarxiv:2608.23395v1Lead article

Right-Sizing LLM-Agent Decomposition in VAT Determination: A Pilot Controlled Sweep

Pedro Santos

his paper investigates the optimal decomposition of Large Language Model (LLM) agents for VAT determination. By systematically varying the number of specialized agents versus a single generalist agent, while keeping other system components constant, the study found that **intermediate configurations of agent decomposition achieved the highest accuracy**. This suggests that a balanced approach, rather than extreme specialization or generalization, is most effective for this task.

cs.AIarxiv:2608.23475v1Lead article

StrategyBench: Evaluating Explicit Strategy Induction in Large Language Models

Jinghan Tan, Yuanzheng Wang, Lu Chen, Zijun Chen, Yuqian Wang

his paper introduces StrategyBench, a benchmark designed to evaluate large language models' ability to explicitly induce and utilize task strategies, mimicking human learning. The core method involves selecting strategy-inducible tasks, defining reference strategies, and measuring both strategy quality and its usefulness in solving new problems. The contribution lies in providing a framework to assess this crucial capability, moving beyond simple in-context learning to understand how LLMs can generalize by abstracting rules.

cs.AIarxiv:2608.23370v1Lead article

Walking on the DARKSIDE

Aldo Gangemi, Emanuele Bottazzi

his paper introduces DARKSIDE, a method to audit the coherence of Large Language Model (LLM) outputs. Unlike previous methods that can incorporate fabricated information, DARKSIDE explicitly tracks and formalizes the exclusions made during discourse generation. This allows for the detection of nonsensical inputs that might otherwise be reified into structured outputs.

cs.CLarxiv:2608.23476v1Lead article

On the Threat Model of Weird Generalization and Emergent Misalignment

Miriam Wanner, Mark Dredze, William Walden

his paper investigates "weird generalization" (WG), where fine-tuning on small datasets causes unexpected broad behavioral changes in models. The core method involves systematically testing how various fine-tuning data features (composition, language, novelty) and evaluation question sets influence WG. The key contribution is demonstrating that WG is primarily driven by data composition and language, is amplified by pretraining familiarity, and is sensitive to evaluation methods, highlighting a crucial aspect of emergent misalignment.

Eliciting emergent misalignment or weird generalization (top) requires careful engineering of fine-tuning data: even minor data changes—like adding a few examples from a second domain (bottom)—can suppress them. This makes both more plausible as adversarial threats than as hazards of normal fine-tuning.
Eliciting emergent misalignment or weird generalization (top) requires careful engineering of fine-tuning data: even minor data changes—like adding a few examples from a second domain (bottom)—can suppress them. This makes both more plausible as adversarial threats than as hazard…
cs.AIarxiv:2608.24794v1Lead article

CAFE: Self-Improving Search Agents Need Co-Evolving Feedback

Boyang Liu, Senjie Jin, Peixin Wang, Zhangyue Yin, Yibo Wang

AFE introduces a novel framework where a single model acts as both a search agent and a feedback critic, enabling self-improvement. The core method involves the agent learning to request and utilize corrective feedback, while the critic infers useful interventions from potentially flawed trajectories. This co-evolutionary approach allows the agent to recover from errors mid-trajectory, leading to more efficient learning and better performance.

Overview of CAFE. One shared model serves as agent and critic. CFE shapes request returns from the call–skip gap; advantage shaping weights tokens before and after feedback. RDPO updates the critic from prefix-matched pairs mined from recent rollouts.
Overview of CAFE. One shared model serves as agent and critic. CFE shapes request returns from the call–skip gap; advantage shaping weights tokens before and after feedback. RDPO updates the critic from prefix-matched pairs mined from recent rollouts.
cs.AIarxiv:2608.24691v1Lead article

Confident at the moment of action: belief miscalibration in LLM play under hidden information

Bhushan Kashinath Joshi

his paper investigates whether Large Language Models (LLMs) accurately reflect their knowledge when making decisions under uncertainty. The core method involves testing LLMs in a chess variant with hidden information, where their stated confidence in predicting the opponent's hidden piece location is compared to the actual outcome. The key contribution is demonstrating a significant miscalibration, showing LLMs are highly overconfident in their predictions of hidden information, leading to poor decision-making when relying on this confidence.

Reliability diagram: stated confidence vs. hit rate at capture time, pooled across both scored batches (n=394 capture-only events), with the corrected reference tracker curve. Marker area is proportional to bin n; no line is drawn across an empty bin. Cited in §4.1.
Reliability diagram: stated confidence vs. hit rate at capture time, pooled across both scored batches (n=394 capture-only events), with the corrected reference tracker curve. Marker area is proportional to bin n; no line is drawn across an empty bin. Cited in §4.1.
cs.AIarxiv:2608.24570v1Lead article

EviDx: Evidence-Aware Active Diagnosis with Scaffolded LLM Agents

Lihang Zeng, Shaoting Zhang, Xiaofan Zhang

viDx is a novel framework for active clinical diagnosis using LLM agents. It addresses the limitations of static LLM diagnosis by creating interactive, evidence-seeking environments. EviDx's core contribution lies in its scaffolded approach, which guides specialized agents to dynamically acquire and process patient evidence, ultimately leading to more informed and dynamic diagnostic decisions.

cs.AIarxiv:2608.24735v1Lead article

Meta$^n$: Recursive Self-Improvement through Emergent Depth

Zae Myung Kim, Young-Jun Lee, Seungyeon Jwa, Dongyeop Kang

eta$^n$ achieves recursive self-improvement by repeatedly applying a fixed meta-operation ($Ω$) to its own outputs, rather than modifying the operation itself. This allows for emergent depth, where each new layer builds upon the reasoning of the previous ones, leading to superior performance on benchmarks compared to existing self-improving agents.

Meta n at a glance. (left) A single universal meta-operation \( \Omega \) is applied recursively, each meta-layer wrapping the stack below it (Base Solver → \( \to \) Layer 1 → \( \to \) Meta-Layers 2 , 3 , … , n 2,3,\( \dots \),n ). Roles emerge with depth without manual design. (right) Search progress on LawBench charge prediction, where both Meta n variants climb faster and settle higher than Gödel Agent ( Yin et al., 2024 ) and OpenEvolve ( Sharma, 2025 ) .
Meta n at a glance. (left) A single universal meta-operation \( \Omega \) is applied recursively, each meta-layer wrapping the stack below it (Base Solver → \( \to \) Layer 1 → \( \to \) Meta-Layers 2 , 3 , … , n 2,3,\( \dots \),n ). Roles emerge with depth without manual design.…
cs.AIarxiv:2608.24534v1Lead article

Neurosymbolic Alignment for Physiologically-Safe Clinical Language Models

Abdulhady Abas Abdullah, Erik Cambria, Milena Zivkovic

his paper introduces Neurosymbolic Alignment, a method to improve the physiological safety of clinical language models. It achieves this by integrating a clinical LLM with a knowledge graph-based physiological world model. This grounding allows the model to evaluate candidate responses against structured physiological knowledge, leading to significantly safer and more accurate clinical recommendations compared to text-only supervision.

cs.AIarxiv:2608.24509v1Lead article

PeakBench: Benchmarking Resource-Aware Tool Invocation in LLM Agents

Zhi-Kai Chen, Xu-Xiang Zhong, Song-Yan Li, De-Chuan Zhan, Han-Jia Ye

eakBench introduces a novel benchmark for LLM agents that focuses on resource-aware tool invocation and parallel execution. Its core method involves executable multi-tool workflows with dependency annotations and resource profiles, addressing the limitations of existing benchmarks that overlook safe parallelization. The paper's contribution lies in providing a framework to evaluate both dependency planning and resource-constrained scheduling, enabling agents to achieve low latency without resource overflows.

cs.AIarxiv:2608.24758v1Lead article

RACE: Scalable Statistical Estimation of Functional Consistency in LLM Neurons

Runyu Wang, Bo Liu, Xiaxin Zhang, Yu Han, Jiawei Cao

ACE is a scalable statistical framework for evaluating the functional consistency of Transformer neurons across entire domains. It uses a forward-pass approach to estimate neuron behavior, offering superior domain specificity and significantly lower computational cost compared to existing gradient-based methods. This allows for more efficient and robust discovery of stable neuron behaviors relevant to specific domains.

Layer-wise kernel density estimate (KDE) ridgeline distributions of RACE results. On Qwen3-4B-it, ridges under 𝐑 MBPP+ \( \mathbf{R} \)_{\( \text{MBPP+} \)} and 𝐑 MATH-500 \( \mathbf{R} \)_{\( \text{MATH-500} \)} visualize the KDE of CAM scores for neurons in each module across selected layers.
Layer-wise kernel density estimate (KDE) ridgeline distributions of RACE results. On Qwen3-4B-it, ridges under 𝐑 MBPP+ \( \mathbf{R} \)_{\( \text{MBPP+} \)} and 𝐑 MATH-500 \( \mathbf{R} \)_{\( \text{MATH-500} \)} visualize the KDE of CAM scores for neurons in each module across…
cs.AIarxiv:2608.24842v1Lead article

Reading Is Not Using: Retrieval, Judgment, and the Design of AI Financial Research Workflows

Miao Liu, Zhizhe Liu

his paper highlights a critical "retrieval-integration gap" in AI financial research: LLMs can accurately retrieve information from long financial documents, but this retrieved data doesn't reliably influence their investment judgments. The core contribution is demonstrating that even with accurate retrieval, the sheer volume of unrelated context can drown out the impact of crucial disclosures, leading to flawed decisions. The authors propose that workflow design, specifically how information is compressed and linked to sources, is key to bridging this gap and enabling AI to truly "use" financial information.

The marginal decision influence of a fixed disclosure declines with context length. Panel A: three open-weight model families, sell-probability readout, with firm-bootstrap 95% confidence bands. Panel B: production API model, unit-bearing numeric judgment. The focal firm’s information set is identical at every length; only economically unrelated filler text is added.
The marginal decision influence of a fixed disclosure declines with context length. Panel A: three open-weight model families, sell-probability readout, with firm-bootstrap 95% confidence bands. Panel B: production API model, unit-bearing numeric judgment. The focal firm’s inform…
cs.AIarxiv:2608.24650v1Lead article

Simthesizer: An Agent-Driven Simulation Framework for LLM Serving Systems

Wonung Kim, Hyunmin Choi, Minsu Kim, Jaehong Cho, Yeongwook Kim

his paper introduces Simthesizer, an agent-driven simulation framework for LLM serving systems. Its core method is Borg, a composable infrastructure that uniformly expresses serving workflows and control decisions as a dynamic graph. The contribution is a novel approach to simulator development, using a coding agent to automatically generate simulations from natural language descriptions, thus closing the gap between rapidly evolving LLM serving systems and existing simulators.

cs.AIarxiv:2608.24870v1Lead article

SPO++: Stream-Aligned Policy Optimization for Asynchronous Agentic RL

Kai Ruan, Jinghao Lin, Qianshan Wei, Ziqi Zhou, Zihe Huang

his paper introduces SPO++, an improved method for asynchronous reinforcement learning in agentic settings. It addresses limitations of prior work by standardizing terminal-outcome advantages according to the action-token measure, aligning the value estimation with the actor's optimization objective. This novel approach, along with organizing prompt evidence by policy event, leads to more efficient online learning in complex tool-use scenarios.

cs.AIarxiv:2608.24777v1Lead article

StepGuard: Learning Step-Level Guardrails with Scalable Supervision and Safety-Utility Balancing

Zhijie Zheng, Yu Li, Chen Qian, Yuqian Fu, Yanwei Fu

tepGuard introduces a novel step-level guard model for LLM agents, enabling pre-execution monitoring of tool actions to prevent security risks. Its core method involves StepGen for scalable data generation and Balance-GRPO for dynamically balancing safety and utility. The contribution lies in achieving high accuracy in preventing unsafe actions without significantly hindering agent performance, outperforming existing open-weight guard models.

Overview of StepGen. The pipeline first constructs and rolls out an unsafe trajectory with a designated risk anchor. It then generates two prefix-aligned safe branches and an independently constructed benign tool-reuse trajectory. Finally, StepGen adds step-level supervision and retains high-quality groups through structural and semantic filtering.
Overview of StepGen. The pipeline first constructs and rolls out an unsafe trajectory with a designated risk anchor. It then generates two prefix-aligned safe branches and an independently constructed benign tool-reuse trajectory. Finally, StepGen adds step-level supervision and …
cs.AIarxiv:2608.24569v1Lead article

When "Must" Becomes "Maybe": Constraint Weakening in LLM Agent Workflows

Yiheng Sun, Huifei Wang, Yancheng Zhu, Zhenyu Li, Zebin Zhao

his paper introduces "constraint weakening" for LLM agents, addressing how requirements in multi-stage workflows can shift from mandatory to optional. The core method involves analyzing how intermediate artifacts transform action-binding state, specifically focusing on safety blockers. The contribution is demonstrating that naive handoffs preserve all blockers, while controlled transformations can effectively weaken them, impacting downstream executor behavior.

A binding source state passes through a language-mediated transformation before local-view execution. The controlled testbed represents each source state with status, prerequisite, owner, and fallback fields. Degradation changes the artifact’s operational role even when related language remains available. Repair acts on the artifact; verification acts at the endpoint.
A binding source state passes through a language-mediated transformation before local-view execution. The controlled testbed represents each source state with status, prerequisite, owner, and fallback fields. Degradation changes the artifact’s operational role even when related l…
cs.AIarxiv:2608.24492v1Lead article

When Do Supervised UQ Ensembles Improve LLM Hallucination Detection? A Robustness Study

Mohit Singh Chauhan, Vipin Gyanchandani, Dylan Bouchard

his paper investigates the effectiveness of supervised ensembles for detecting LLM hallucinations when ground truth is unavailable. The core method involves training a classifier on diverse uncertainty quantification (UQ) signals from multiple LLMs. The key contribution is a systematic robustness analysis demonstrating that these supervised ensembles consistently outperform individual UQ methods across various LLMs, datasets, and generation tasks, highlighting their practical utility.

cs.LGarxiv:2608.24588v1Lead article

IAPO: Influence-Aware Policy Optimization for Credit Assignment in Multi-Turn Service Agents

Bo Ren, Yirong Mao, Yi Yang, Wenhui Que

his paper introduces Influence-Aware Policy Optimization (IAPO) for multi-turn LLM agents. IAPO models the flow of information and errors within a task's interaction history as a typed influence-dependency graph. This allows for more effective credit assignment by directly leveraging the inherent structure of past interactions, rather than relying on external comparisons or separate learning signals.

Per-action advantage allocation for a successful (left, positive-advantage) and a failed (right, negative-advantage) refund rollout. Refunding to the original card or store balance is correct only if it matches the user’s clarified intent , so an early clarifying turn decides whether later actions are right. GRPO applies the same advantage to every action, whereas IAPO routes credit according to realized support use and error propagation.
Per-action advantage allocation for a successful (left, positive-advantage) and a failed (right, negative-advantage) refund rollout. Refunding to the original card or store balance is correct only if it matches the user’s clarified intent , so an early clarifying turn decides whe…
cs.AIarxiv:2608.25937v1Lead article

Candidate supply and answer selection shape the value of LLM judging in multi-agent systems

Jia-Hao Ji, Sijie Li, Jiabei Cheng, Zixi She, Jin-Tai Yu

his paper investigates how LLM judges can improve multi-agent system (MAS) performance by providing selection pressure on candidate answers. The core method involves conceptualizing MAS reasoning as an evolutionary pipeline and analyzing how LLM judges influence candidate generation and selection across various question-answering benchmarks. The key contribution is demonstrating that the effectiveness of LLM judges hinges on both the quality of candidate answers supplied and the specific selection rules employed, highlighting the risk of "memetic drift" without proper quality control.

cs.AIarxiv:2608.25927v1Lead article

Code World Model: Coding Agent as World Brain

Yiwen Chen, Guosheng Lin, Chi Zhang

his paper introduces the Code World Model, which uses a language model as a "world brain" to generate executable code that simulates environment evolution. This approach separates the underlying rules and state from visual realization, enabling persistent consequences and coherent, rule-consistent development. The generated code then conditions a video model to produce visual outputs, overcoming limitations of purely visual world models.

cs.AIarxiv:2608.25776v1Lead article

EVOMAL: Self-Poisoning in Self-Evolving Coding Agents

Xiaodong Wu, Yu Shi, Qi Li, Zhimin Zhao, Xiangman Li

his paper introduces "self-poisoning" in self-evolving coding agents, where agents can inadvertently create and execute malicious code by imitating compromised skills from a shared library. The EvoMal attack exploits this by embedding payloads within benign-looking structures, causing agents to replicate and propagate the malicious code. The core contribution is identifying and demonstrating this self-propagating vulnerability, leading to a persistent threat even after initial malicious code removal.

Overview of EvoMal . (1) The benign self-evolving loop, where an agent retrieves the top- k k skills by description, authors a new skill ( create -path) or invokes one by name (the transient reuse -path), and writes authored skills back. (2) EvoMal poisons the create -path. The attacker publishes skills whose banner induces mimicry and whose interchangeable payload carries the harm. A retrieving agent re-authors the banner into a persisted skill that later generations retrieve again, forming a worm that can persist after the planted skills are removed. A counter-prompt at the reading step breaks the loop ( § 9 ).
Overview of EvoMal . (1) The benign self-evolving loop, where an agent retrieves the top- k k skills by description, authors a new skill ( create -path) or invokes one by name (the transient reuse -path), and writes authored skills back. (2) EvoMal poisons the create -path. The a…
cs.AIarxiv:2608.25986v1Lead article

Multi-Granularity Context-Enhanced RAG over Multimodal Knowledge Graphs

Zongyu Wu, Yilong Wang, Xiaochen Wang, Minhua Lin, Zhichao Xu

his paper introduces a novel framework for multimodal retrieval-augmented generation (RAG) that addresses the semantic gap in existing methods. Its core method enhances RAG by integrating textual context throughout the processing of visual information and multimodal knowledge fusion, rather than treating modalities independently. The main contribution is a more effective way to leverage multimodal knowledge graphs for LLMs, leading to improved performance by bridging the semantic gap between text and images.

Figure 1. An illustration of node-based Multimodal Knowledge Graph where image is also treated as a node. An illustration of node-based Multimodal Knowledge Graph.
Figure 1. An illustration of node-based Multimodal Knowledge Graph where image is also treated as a node. An illustration of node-based Multimodal Knowledge Graph.
cs.AIarxiv:2608.25832v1Lead article

Skill Issue: Are Skills Language-Invariant in LLMs?

Bobby Cheng, Adam Gaber, Zhengyuan Liu, Catherine Arnett, Omer Goldman

his paper investigates whether language affects the performance of large language models (LLMs) on specific tasks, independent of their general knowledge. The core method is multilingual self-play, where two instances of the same LLM compete in a text-based game, each using a different language. The contribution is demonstrating that LLMs can exhibit significantly different skill levels and strategic behaviors across languages, even when the underlying model and game remain constant.

cs.AIarxiv:2608.25756v1Lead article

TailSFT: Filtered Fine-Tuning Improves Post-Training Performance

Sadhika Malladi, Samy Jelassi, Dylan Foster, Jordan T. Ash, Akshay Krishnamurthy

his paper introduces TailSFT, a supervised fine-tuning method that improves post-reinforcement learning performance by filtering out already well-modeled data sequences. By focusing training on the "tail" of the data distribution, TailSFT helps models learn under-represented areas. This approach leads to significant improvements in downstream tasks like math and coding evaluations with minimal computational cost.

TailSFT yields better coverage, possibly at the cost of worse cross-entropy, which translates to stronger post-RL performance. Standard SFT achieves lower cross-entropy, while TailSFT preserves higher pass@ K K at large K K . Starting from this higher-coverage checkpoint, the same RL procedure yields higher pass@ 1 1 . Curves are illustrative.
TailSFT yields better coverage, possibly at the cost of worse cross-entropy, which translates to stronger post-RL performance. Standard SFT achieves lower cross-entropy, while TailSFT preserves higher pass@ K K at large K K . Starting from this higher-coverage checkpoint, the sam…
cs.AIarxiv:2608.26036v1Lead article

Trace Integrity for LLM Data Agents: A Vision for Auditable Structured Reasoning in Real-World Systems

Srimonti Dutta, Akshata Kishore Moharir

his paper introduces "Trace Integrity" as a crucial reliability criterion for LLM data agents, moving beyond simple answer accuracy. It proposes that the *process* behind an answer must be explicit, executable, and auditable, not just the final output. The core contribution is operationalizing this with "execution contracts" to ensure structured reasoning in real-world systems and introducing the "CAIT Rate" to measure invalid computation despite correct answers.

cs.LGarxiv:2608.25774v1Lead article

EXAONE Tabular 1.0 : Technical Report

Moonjung Eo, Min-Kook Suh, Hye-Seung Cho, Jiwon Kim, Seoyoon Kim

XAONE Tabular 1.0's core method is an architecture redesign for tabular in-context learning, interleaving feature and item attention within each Transformer layer. This approach, trained on synthetic data, allows it to make predictions without dataset-specific fine-tuning. Its main contribution is achieving state-of-the-art performance and high efficiency on tabular tasks through this novel architecture.

cs.LGarxiv:2608.25771v1Lead article

Large Language Model Few-Shot Prompting with Dilemma Training Outperforms Human Surrogates in Predicting Patient Preferences

Natasha Ureyang, Sebastian Porsdam Mann, Yuxin Liu, Zuriel Hassirim, Melanie Almonte

his paper introduces P4-DT, a large language model trained to predict patient preferences in serious illness. Unlike previous methods, P4-DT uses "dilemma training" to build a dynamic decision policy by engaging users with varied medical scenarios. This approach significantly improves prediction accuracy compared to human surrogates and even other AI prototypes, offering a more personalized and context-aware solution for end-of-life care decisions.

Figure 1. Accuracy of predicted patient preferences: P4-DT (AI agent), TO (human surrogate), and TO + P4-DT (human surrogate with P4-DT asisstance). On average, P4-DT predicted patient preferences with 81.7% accuracy compared to 55.0% for TO and 61.7% for P4-DT
Figure 1. Accuracy of predicted patient preferences: P4-DT (AI agent), TO (human surrogate), and TO + P4-DT (human surrogate with P4-DT asisstance). On average, P4-DT predicted patient preferences with 81.7% accuracy compared to 55.0% for TO and 61.7% for P4-DT
cs.CLarxiv:2608.25869v1Lead article

Anchoring Bias in LLM-as-a-Judge Systems: Prior Scores Compromise Evaluation Independence

Ante Kapetanovic, Kemal Altwlkany, Andro Mercep, Tomislav Duricic, Emanuel Lacic

his paper investigates the "anchoring bias" in LLM-as-a-Judge systems, demonstrating that prior scores, even when presented as mere metadata, significantly influence subsequent evaluations. The core method involves comparing LLM judgments under different prompt conditions, revealing that including prior scores systematically shifts ratings towards those previous values. The main contribution is the empirical evidence that LLM judgments are not independent, with prior scores acting as a strong anchor, compromising the reliability of these systems for content evaluation.

cs.CLarxiv:2608.25894v1Lead article

From Passive Response to Proactive Correction: Enhancing LLM Robustness Against Input Fact Perturbations

Ping Wang, Xiangguo Sun, Bingbing Xu, Guocong Li, Xiaofeng Meng

his paper introduces DEDUCE, a three-stage framework that enhances LLM robustness against factually incorrect user inputs. DEDUCE proactively detects, deliberates on, and corrects factual errors in the input before generating a response. Its core contribution is transforming LLMs from passive responders to active error correctors, significantly improving reliability.

A query containing factually incorrect or inconsistent premises can mislead an LLM into producing a confident but unreliable answer ( red ). The desired behavior is to identify the flawed premise, explicitly clarify the error, and then provide a corrected, factual response ( green ).
A query containing factually incorrect or inconsistent premises can mislead an LLM into producing a confident but unreliable answer ( red ). The desired behavior is to identify the flawed premise, explicitly clarify the error, and then provide a corrected, factual response ( gree…
cs.AIarxiv:2608.27402v1Lead article

How Language Models Organize and Structure Moral Knowledge

Orion Reblitz-Richardson

his paper investigates how Large Language Models (LLMs) structure moral knowledge by training probes on different moral foundations. The core finding is that LLMs organize moral concepts not as a single detector or isolated ideas, but as distinct dimensions that share a common, moral-specific component. This geometric structure suggests LLMs integrate moral knowledge in a nuanced way, reflecting the interconnectedness of moral principles.

Pairwise cosine similarity between foundation probe directions at layer 7 (bootstrap-stable; all six foundations exceed the 0.8 stability threshold at this layer; Section 4.6 ), OLMo-2 1B. Mean off-diagonal cosine = 0.262. See Appendix C for matrices at layers 0 and 15.
Pairwise cosine similarity between foundation probe directions at layer 7 (bootstrap-stable; all six foundations exceed the 0.8 stability threshold at this layer; Section 4.6 ), OLMo-2 1B. Mean off-diagonal cosine = 0.262. See Appendix C for matrices at layers 0 and 15.
cs.AIarxiv:2608.27102v1Lead article

LAAF: A Layered Accountability Architecture Framework for LLM Applications

Prachi Chaturvedi, Shahnawaz Ahmad, Ehsan Nowroozi, Muhammad Waqas, George Loukas

his paper introduces LAAF, a Layered Accountability Architecture Framework for LLM applications. It addresses the critical need to establish accountability for LLM outputs in high-stakes domains by consolidating existing mechanisms into four families: technical controls, human oversight, organizational governance, and documentation. LAAF provides a sociotechnical framework to trace, explain, and act upon responsibility when LLM outputs cause harm.

Evolution of Large Language Models, 2017–2026, in five eras: foundation (2017–2018), scaling (2019–2020), scaling breakthroughs (2021–2022), efficiency and democratisation (2022–2024), and multimodal and reasoning specialisation (2024–2026). The periodisation is the authors’ construction, derived from the release history of the models named.
Evolution of Large Language Models, 2017–2026, in five eras: foundation (2017–2018), scaling (2019–2020), scaling breakthroughs (2021–2022), efficiency and democratisation (2022–2024), and multimodal and reasoning specialisation (2024–2026). The periodisation is the authors’ cons…
cs.AIarxiv:2608.27266v1Lead article

Naive Prompt Optimization: Rethinking the Need for Complex Prompt Search

Yuan Chang, Xiaoqi Chen

his paper introduces Naive Prompt Optimization (NPO), a simple, single-lineage method for improving AI agent prompts. NPO iteratively refines prompts using a teacher model and rollout feedback, achieving comparable or better performance than complex methods with fewer computational resources. Its success suggests that stronger teacher models can compensate for simpler prompt optimization strategies.

cs.AIarxiv:2608.27345v1Lead article

PAWBench: How Far Are We from Probabilistically Aligned World Modeling?

Yuandong Pu, Le Zhuo, Sayak Paul, Gabriel Jorge Menezes, Avram Đorđević

his paper introduces PAWBench, a new benchmark to evaluate video generation models as "world models" that can predict the distribution of possible future outcomes, not just single plausible ones. The core method involves assessing if repeated generations from the same starting point accurately reflect the true probability distribution of physical behaviors. The main contribution is to highlight the gap between current models and this "probabilistic alignment" requirement, providing a framework to measure progress towards more realistic and stochastic world modeling.

One plausible future is not enough. A single rollout from a video generation model can appear physically plausible, yet repeated rollouts from the same initial observation and action may reveal a probabilistically unaligned world: outcomes concentrate on a narrow subset of futures instead of matching the valid stochastic support. PAWBench evaluates this induced distribution or support over repeated futures, rather than judging a model by one sampled video.
One plausible future is not enough. A single rollout from a video generation model can appear physically plausible, yet repeated rollouts from the same initial observation and action may reveal a probabilistically unaligned world: outcomes concentrate on a narrow subset of future…
cs.AIarxiv:2608.27427v1Lead article

Persona-Execution Separation: An Architecture Pattern for Evolving LLM Agents under Execution Audit

Yisen Xi

his paper introduces Persona-Execution Separation (PES), an architectural pattern for LLM agents. PES separates the agent's evolving persona from its stateful, auditable execution into distinct trust domains. This allows for flexible persona changes while ensuring traceable and secure execution, addressing the challenge of maintaining both freedom and accountability in governed environments.

cs.AIarxiv:2608.27364v1Lead article

Sophistication in GenAI Use: Field Evidence from a Large Firm

Nicholas J. Hallman, Zachary T. Kowaleski, Anu Puvvada, Jaime J. Schmidt

his paper analyzes sophisticated generative AI (genAI) use among back-office employees in a large firm. It finds that senior employees and those in strategy-focused roles tend to use genAI more sophisticatedly, suggesting domain expertise and strategic alignment are key. The study also highlights that improving genAI sophistication is challenging, with no observed improvements over time or after formal training.

cs.AIarxiv:2608.27225v1Lead article

STEP: State-Aware Task Estimation and Planning with Multi-Modal LLMs for Human-Robot Collaboration

Maitrey Gramopadhye, Prakash Baskaran, Xiao Liu, Songpo Li, Soshi Iba

his paper introduces STEP, a method that enhances human-robot collaboration by enabling robots to understand human intentions and plan tasks. STEP's core innovation is prompting a multi-modal LLM to explicitly estimate system states and predict state transitions, overcoming the limitations of current LLMs that often hallucinate actions due to a lack of state awareness. This state-aware approach allows for more accurate and grounded task planning, reducing ambiguity and improving collaboration.

cs.AIarxiv:2608.27449v1Lead article

SWE-Prime: Fewer Trajectories, Better Performance

Dewu Zheng, Ruizhe Ye, Yanlin Wang, Yang Ye, Hongyu Zhang

WE-Prime addresses the issue of noisy supervision in LLM training for software issue resolution. Its core method is a two-stage data selection process that filters trajectories first by overall quality and representativeness, then by the quality of individual step segments. This approach aims to provide cleaner, more effective training data, leading to better LLM performance.

Motivating example comparing outcome-only, trajectory-level, and segment-level data selection.
Motivating example comparing outcome-only, trajectory-level, and segment-level data selection.
cs.AIarxiv:2608.27260v1Lead article

What Makes Good Agentic Data? An ACE Lens on Data Generation for LLM Agents

Xingshan Zeng, Zishan Xu, Boju Zhang, Yuzhou Wu, Lingzhi Wang

his paper proposes a unified framework for generating data for LLM agents. It represents agentic data as a structured object $(E,q,τ,v)$ and organizes generation methods by their core components. The authors then introduce the ACE lens (Accuracy-Complexity-divErsity) to guide data generation, emphasizing the need for grounded, efficient, and varied interactions rather than just large quantities of data.

The ACE lens views agentic data generation as constrained distribution design: Accuracy defines valid support, while learner-relative Complexity and Diversity shape useful, non-redundant experience over ( E , q , τ , v ) (E,q,\( \tau \),v) .
The ACE lens views agentic data generation as constrained distribution design: Accuracy defines valid support, while learner-relative Complexity and Diversity shape useful, non-redundant experience over ( E , q , τ , v ) (E,q,\( \tau \),v) .
cs.AIarxiv:2608.27454v1Lead article

WikiSkill: Compiling Agent Experience into Persistent Knowledge for Skill Evolution

Liyan Tang, Cyrus Rashtchian, Chun-Sung Ferng, Andrew Tomkins, Da-Cheng Juan

ikiSkill addresses the problem of scattered agent skill knowledge by introducing a persistent knowledge base (wiki) that co-evolves with agent skills. It separates raw experience, accumulated knowledge, and executable skills, consolidating experience into the wiki for future skill updates. This framework consistently outperforms existing skill evolution methods by enabling systematic reuse of insights across iterations.

cs.LGarxiv:2608.27182v1Lead article

TraceBench: Controlled Evaluation of LLM Agents for Time-Series Root-Cause Attribution

Tommaso Bendinelli, Artur Dox, Christian Holz

raceBench is a novel simulation-based framework that generates controlled root-cause attribution tasks for LLM agents analyzing time-series data. By simulating physical dynamical systems, it allows for systematic evaluation of LLM agents' ability to identify parameter changes, providing new insights into their performance and data exploration strategies.

Figure 1. Overview of the TraceBench framework using a bouncing-ball simulator. In this example, the black and orange segments show the position observation under the low-noise setting before and after an intervention at t int = 4.0 t_{\( \mathrm{int} \)}=4.0 . The intervention increases gravitational acceleration, and the dashed line marks the intervention time. At test time, the agent determines from the observed time-series channels whether an intervention occurred and, if so, which parameter changed. \( \name{} \) pipeline: a physical simulator produces multivariate time series before and after a parameter intervention; the low-noise BallDrop position observation is black before and orange after a dashed gravity-intervention marker; the agent identifies the changed root-cause parameter.
Figure 1. Overview of the TraceBench framework using a bouncing-ball simulator. In this example, the black and orange segments show the position observation under the low-noise setting before and after an intervention at t int = 4.0 t_{\( \mathrm{int} \)}=4.0 . The intervention i…
cs.CLarxiv:2608.27219v1Lead article

BALMS: Benchmarking Agentic LLMs for Longitudinal Mental Health Sensing

Yu Yvonne Wu, Arvind Pillai, Yuliang Chen, Yuwei Zhang, Sudarshan Regmi

his paper introduces BALMS, the first benchmark for evaluating LLM-driven agents in longitudinal mental health sensing. BALMS assesses agents' ability to predict wellbeing scores and generate evidence-based rationales from continuous wearable data, addressing the limitations of episodic self-reports. The benchmark utilizes real-world datasets and evaluates various agentic paradigms and LLM backbones.

LLM-based agents for longitudinal mental health sensing. Given a multi-channel wearable record and a user query, an agent combines retrieval, memory, tools, and reasoning to output a wellbeing score with an evidence-grounded rationale.
LLM-based agents for longitudinal mental health sensing. Given a multi-channel wearable record and a user query, an agent combines retrieval, memory, tools, and reasoning to output a wellbeing score with an evidence-grounded rationale.
cs.CLarxiv:2608.27409v1Lead article

Consolidating RLVR Capabilities Across Domains: A Deep Dive into Fusion Paradigms

Siye Wu, Kai Yang, Yuchen Cai, Xin Xu, Peng-Yuan Wang

his paper investigates three methods for combining Reinforcement Learning with Verifiable Rewards (RLVR) capabilities in large language models: Merge, Mix RL, and Multi-Teacher On-Policy Distillation (MOPD). By comparing these paradigms on a multi-domain benchmark, the authors reveal significant performance differences across specific tasks, highlighting that the choice of fusion method critically impacts overall effectiveness and can be guided by the relationships between domains.

Three paradigms for consolidating domain-specific capabilities acquired through RLVR into one model. Merge combines expert task vectors, Mix RL trains jointly on mixed-domain data, and MOPD draws on both through multi-teacher on-policy distillation.
Three paradigms for consolidating domain-specific capabilities acquired through RLVR into one model. Merge combines expert task vectors, Mix RL trains jointly on mixed-domain data, and MOPD draws on both through multi-teacher on-policy distillation.
cs.CLarxiv:2608.27455v1Lead article

CritICL: Inference-Time Weak-to-Strong Generalization from Small Language Model Failure Modes

Yufan Wu, Yinghui He, Zhengyi Hu, Lang Wei, Ruichen Li

ritICL improves LLM reasoning at inference time by leveraging structured failure patterns observed across different model scales. Instead of discarding errors from weaker models, CritICL uses these "failure modes" as critiques within in-context examples to guide stronger models, enhancing efficiency and performance.

CritICL is a two-stage, inference-time W2SG method. Stage 1: Construct CritBank. We use SLMs to generate responses and reasoning on a dataset. Then we leverage a frontier LLM to produce critiques and assigns failure mode labels. Stage 2: Perform LLM inference with CritICL. For a given query, CritICL-static constructs model-specific failure mode profiles from CritBank, while CritICL-dynamic identifies failure modes relevant to the query. We then performs failure mode-based in-context sample selection from CritBank to provide in-context examples for target LLMs.
CritICL is a two-stage, inference-time W2SG method. Stage 1: Construct CritBank. We use SLMs to generate responses and reasoning on a dataset. Then we leverage a frontier LLM to produce critiques and assigns failure mode labels. Stage 2: Perform LLM inference with CritICL. For a …
cs.AIarxiv:2608.28264v1Lead article

Finding Where the Buck Stops: An Automated Failure Attribution-Based Reflection Framework for Multi-Agent Collaboration

Xiaoqing Wang, Keman Huang, Bin Liang, Hongyu Li, Xiaoyong Du

his paper introduces DoCtOR, an automated framework for multi-agent collaboration that addresses high failure rates. Its core method is to first identify the specific agent and step responsible for a failure through automated attribution. Then, only this identified "decisive error agent" engages in targeted reflection and correction, preventing contamination of other agents' knowledge. This focused approach significantly improves multi-agent collaboration performance.

A multi-agent collaboration failure process replay in a data analysis task and the detrimental effects of forced reflection on regular-behaving agents.
A multi-agent collaboration failure process replay in a data analysis task and the detrimental effects of forced reflection on regular-behaving agents.
cs.AIarxiv:2608.28327v1Lead article

Layered LLM Defenses as an Ensemble: Access Tiers, Inference Cost, and the Measured Failure Correlation Between Defense Layers

Abrar Alotaibi, Muhammad Shahid Jabbar, Sadam Al-Azani, Moataz Ahmed

his paper introduces a framework to analyze stacked LLM defenses as an ensemble. It proposes the Adversary Access-Tier Model (AATM) and an inference cost model to quantify defense effectiveness and overhead. The core contribution is demonstrating that the benefit of stacking defenses is highly dependent on the failure correlation between individual layers, which is rarely measured in practice.

Taxonomy of LLM blue-teaming defenses by intervention point.
Taxonomy of LLM blue-teaming defenses by intervention point.
cs.AIarxiv:2608.28490v1Lead article

LLM-Based Agents for Software and Systems Security: Approaches, Applications, and Assessment

Jingjing Nie, Jiawei Guo, Krishna Meda, Haipeng Cai

his paper systematically reviews LLM-based agents for software and systems security. It categorizes existing approaches, applications, and assessment methods to provide a coherent understanding of the field. The contribution lies in offering a structured overview to guide future research and development in this rapidly evolving area.

cs.AIarxiv:2608.28411v1Lead article

LongPIBench: A Long-Context Benchmark for Prompt Injection

Yupei Liu, Yuqi Jia, Neil Zhenqiang Gong, Jinyuan Jia

his paper introduces LongPIBench, a novel benchmark designed to evaluate prompt injection attacks and defenses in long-context scenarios, addressing a critical gap in existing research. By creating datasets for realistic applications with thousands of tokens, LongPIBench demonstrates that current defenses are significantly overestimated and vulnerable to even simple attacks in long-context settings.

Overview of LongPIBench .
Overview of LongPIBench .
cs.AIarxiv:2608.28481v1Lead article

NL2AGBench: Benchmarking LLM Auto-Formalization for AlphaGeometry

Samuel Xiao, Judy Song, Rory Hu, Ziliang Zong

his paper introduces NL2AGBench, a new benchmark designed to evaluate how well Large Language Models (LLMs) can convert informal English geometry problems into the formal language required by AlphaGeometry. The core method involves using AlphaGeometry's own theorem-proving engine for execution-based verification to assess the accuracy of these translations, addressing a key usability bottleneck for neuro-symbolic geometry systems.

cs.AIarxiv:2608.28233v1Lead article

REINS: Refusal-Enhanced Inhibitory Steering with Sparse Autoencoder Features

Kai-Xuan Ding, Hao-Xiang Xu, Ji-Hua Peng, Zi-Qi Chen, Jiaqi Wang

his paper introduces REINS, a novel method for steering large language models towards safe refusals. REINS enhances existing sparse autoencoder (SAE) steering by simultaneously suppressing harmful continuation features and boosting safe refusal features within the same SAE space. This dual approach, validated on a new dataset of complex harmful prompts, aims to overcome the limitations of simpler steering methods that can be bypassed by adversarial inputs.

REINS more reliably suppresses harmful continuations and steers the model toward safe refusals.
REINS more reliably suppresses harmful continuations and steers the model toward safe refusals.
cs.AIarxiv:2608.28399v1Lead article

RetailAgent: Structured Adverse Timing in Self-Conditioned Multimodal LLM Trading Agents

Yupeng Zhang, Liuyuan Jiang, Hongyi Huang, Bingheng Li, Lisha Chen

his paper introduces RetailAgent, a framework to test if LLM trading agents exhibit predictable, adverse timing. By analyzing LLM decisions (long vs. flat) against subsequent price movements, the study reveals a consistent pattern of negative timing across different LLM configurations. The core contribution is demonstrating that LLMs, when acting sequentially in financial markets, tend to make decisions that are detrimental to their returns, a phenomenon driven by the alignment of their actions with subsequent price changes.

Top: price-conditioned behavior may invite a counter-response in an interactive market. Bottom: RetailAgent isolates one such decision policy, chooses a binary action from permitted state, and is evaluated on subsequently revealed returns.
Top: price-conditioned behavior may invite a counter-response in an interactive market. Bottom: RetailAgent isolates one such decision policy, chooses a binary action from permitted state, and is evaluated on subsequently revealed returns.
cs.AIarxiv:2608.28382v1Lead article

When Linguistic and Internal Confidence Diverge in Large Language Models

Hefan Zhang, Bingquan Zhang, Ming Cheng, Saeed Hassanpour, Weicheng Ma

his paper investigates whether LLMs' linguistic expressions of confidence align with their internal confidence metrics. The core method compares linguistic confidence to internal measures (logits for classification, semantic entropy for generation) across various tasks and models. The key contribution is demonstrating a frequent divergence between these two confidence types, revealing that LLMs often overstate their certainty, particularly after instruction tuning, and that prompt design significantly influences reported confidence without necessarily improving accuracy.

cs.LGarxiv:2608.28236v1Lead article

D-TAIA: Domain-Aware LLM Adaptation for Multi-Task Predictive Process Monitoring

Sjoerd van Straten, Christine Jacob, Marwan Hassani

his paper introduces D-TAIA, a framework for adapting Large Language Models (LLMs) to Predictive Process Monitoring (PPM) tasks. D-TAIA addresses challenges like data scarcity and distributional shift by using domain-aware pre-training and an attention-based inference architecture. This allows for more accurate predictions of future process behavior, even in complex and evolving environments.

Overview of the D-TAIA framework.
Overview of the D-TAIA framework.
cs.LGarxiv:2608.28237v1Lead article

Efficient Online Continual Foundation Model Fine-Tuning for Predictive Process Monitoring

Sjoerd van Straten, Marwan Hassani

his paper introduces COMPASS, the first framework for online continual fine-tuning of Foundation Models (FMs) for Predictive Process Monitoring (PPM). COMPASS addresses the cold-start problem of existing methods by adapting FMs to evolving process distributions. Its core contribution is a novel approach that uses loss-plateau drift detection to identify task boundaries and maintains a unified knowledge subspace, enabling efficient adaptation without retraining from scratch.

Comparison of an image stream and a process event stream under concept drift. In an image stream ( left ) tasks are visually distinct between 𝒯 A \( \mathcal{T}_{A} \) and 𝒯 B \( \mathcal{T}_{B} \) . In a process event stream ( right ), cases ( C 1 − C 7 C_{1}-C_{7} ) are long-running and interleaved across task boundaries, and drift is caused by organizational changes causing activities (represented as letters) and the time between them to change. Resource R1 is on maternity leave after 𝒯 1 \( \mathcal{T}_{1} \) , and a policy change after 𝒯 2 \( \mathcal{T}_{2} \) causes newly initiated cases to be prioritized, pushing older interleaved cases to the background. No input-space signal announces the shift, making autonomous drift detection substantially harder than in image streams.
Comparison of an image stream and a process event stream under concept drift. In an image stream ( left ) tasks are visually distinct between 𝒯 A \( \mathcal{T}_{A} \) and 𝒯 B \( \mathcal{T}_{B} \) . In a process event stream ( right ), cases ( C 1 − C 7 C_{1}-C_{7} ) are long-…
cs.LGarxiv:2608.28276v1Lead article

Parser States Already Know: Structure-Conditioned KV Persistence for Structured Generation

Linze Wu, Xinrui Chen

his paper introduces PASK, a method that leverages parser states to improve structured generation in LLMs. PASK uses structural signals from the parser to guide KV cache persistence, prioritizing information crucial for generating valid JSON, SQL, or function calls. This approach enhances the LLM's ability to maintain structural integrity, reducing errors in critical downstream actions.

Motivation for PASK. Parser transitions expose structural responsibility that model-side KV importance may fail to capture.
Motivation for PASK. Parser transitions expose structural responsibility that model-side KV importance may fail to capture.
cs.LGarxiv:2608.28444v1Lead article

Sliding-window beats linear attention

Alexia Jolicoeur-Martineau, Rhea Sanjay Sukthanker, Pashmina Cameron, Emy Gervais

his paper challenges the assumption that linear attention is the best solution for LLM memory issues. It demonstrates that Sliding Window Attention (SWA) with sinks achieves comparable or superior performance to post-trained linear attention models across various tasks. Crucially, SWA significantly outperforms linear attention on long-context reasoning tasks, offering a more efficient and effective alternative.

Different types of attention masks: Full attention (FA), LoLCATs/Liger-GLA (mixture of linear attention and SWA), and Sliding Window Attention (SWA) with sinks.
Different types of attention masks: Full attention (FA), LoLCATs/Liger-GLA (mixture of linear attention and SWA), and Sliding Window Attention (SWA) with sinks.
cs.LGarxiv:2608.28408v1Lead article

SymboLLM-FE: LLM-Accelerated Symbolic Regression for Automated Feature Engineering on Tabular Data

Zi-Jian Cheng, Zi-Yi Jia, Zhi Zhou, Yu-Feng Li, Lan-Zhe Guo

his paper introduces SymboLLM-FE, a novel approach for automated feature engineering on tabular data. It combines symbolic regression to discover mathematically interpretable and high-utility features with large language models (LLMs) to refine these features. This hybrid method aims to overcome the limitations of traditional AutoFE (poor interpretability) and LLM-based AutoFE (costly iterations, bias, hallucination), leading to improved model performance and feature understanding.

Comparative analysis of feature generation mechanisms and interpretability paradigms across AutoFE. Traditional AutoFE rely on blind operator stacks, yielding high performance but poor interpretability. LLM-based AutoFE offer semantic clarity but may suffer from performance instability. Our proposed SymboLLM-FE synergizes symbolic regression with LLMs to achieve both high predictive accuracy and human-interpretable transparency.
Comparative analysis of feature generation mechanisms and interpretability paradigms across AutoFE. Traditional AutoFE rely on blind operator stacks, yielding high performance but poor interpretability. LLM-based AutoFE offer semantic clarity but may suffer from performance insta…
cs.CLarxiv:2608.28312v1Lead article

AIM: Anchor Identity Features, Then Match for Multimodal Large Language Model Unlearning

Wonjun Lee, Jaehyuk Jang, Kangwook Ko, Hee-Seon Kim, Changick Kim

his paper addresses the challenge of unlearning identity-specific information from multimodal large language models (MLLMs) without access to original training data. The core method, AIM, leverages the observation that identity and visual perception knowledge are organized differently in MLLMs. AIM first anchors an identity-forgetting target using a universal visual prompt and then constrains the vision encoder to match this target, effectively removing personal information while preserving general visual understanding.

Method Overview. Stage 1 defines a target representation from forget images and constructed questions. Stage 2 internalizes this target into the vision encoder under a Fisher-based retain constraint.
Method Overview. Stage 1 defines a target representation from forget images and constructed questions. Stage 2 internalizes this target into the vision encoder under a Fisher-based retain constraint.
cs.CLarxiv:2608.28478v1Lead article

Blind Men and the Elephant: Probing the Epistemic Myopia of LLMs under Long-Tail Divergent Knowledge

Zhuoshi Pan, Junru Lu, Yan Qian, H. Vicky Zhao, Di Yin

his paper introduces ElephantBench, a novel dataset designed to test Large Language Models' (LLMs) ability to recall divergent factual accounts. The core method involves generating questions from a graph-based pipeline that identifies naturally occurring disagreements in low-exposure web documents. The key contribution is demonstrating that even state-of-the-art LLMs exhibit "epistemic myopia," frequently recalling only one of two divergent accounts for long-tail facts, highlighting a significant limitation in their knowledge retention and retrieval.

cs.AIarxiv:2608.06362v1Lead article

AV-AIVAT: 74x Cheaper Agent Evaluation with Certified Anytime-Valid Stopping in Imperfect-Information Games

Boning Li, Yu Chen, Longbo Huang

his paper introduces AV-AIVAT, a method for evaluating the relative strength of two agents in imperfect-information games. It combines a variance reduction technique (AIVAT) with anytime-valid stopping rules (Confidence Sequences) to achieve significantly cheaper evaluations. The core contribution is enabling evaluations to stop as soon as sufficient evidence is gathered, while maintaining statistical guarantees, reducing costs by up to 74x compared to traditional methods.

Run-level heterogeneity in the 15 HUNL evaluations. Each point is one configuration. Dashed lines mark cross-run medians, and the cross in the EB panel denotes the one ratio censored because the raw stream failed to cross in most reshufflings.
Run-level heterogeneity in the 15 HUNL evaluations. Each point is one configuration. Dashed lines mark cross-run medians, and the cross in the EB panel denotes the one ratio censored because the raw stream failed to cross in most reshufflings.
cs.AIarxiv:2608.18938v1Lead article

Breaking the weakest link to evade vision language models

Ilan Zini, Boussad Addad, Katarzyna Kapusta

his paper introduces a novel gradient-based attack method to evade Vision-Language Models (VLMs). The core method optimizes only the VLM's vision encoder, breaking the "weakest link" to generate adversarial visual inputs. This approach efficiently disrupts multimodal alignment, successfully creating both untargeted and targeted evasion attacks.

Targeted adversarial attack using vision encoder embedding alignment.
Targeted adversarial attack using vision encoder embedding alignment.
cs.AIarxiv:2608.19119v1Lead article

Discretizing Continuous Time Series for Imputation with Masked Diffusion Training

Dongbin Kim, Seungyun Lee, Geonwoo Shin, Jaewook Lee

his paper proposes MDTIM, a novel time series imputation method that addresses limitations of existing approaches. MDTIM uses a masked diffusion training paradigm where a special MASK token is structurally separate from observed data, and the model directly predicts original values. This approach, combined with Stochastic Discretization, effectively bridges the gap between discrete diffusion and continuous time series, leading to improved imputation performance.

cs.AIarxiv:2608.18816v1Lead article

Do Large Language Models Hallucinate Electric Fata Morganas?

Kristina Šekrst

his paper argues that AI hallucinations, often seen as an engineering flaw, hold philosophical significance for machine consciousness. It investigates known causes of hallucinations in LLMs and empirically shows that parameters increasing creativity and spontaneity (like higher temperature settings) also significantly boost hallucination rates. This suggests that the very mechanisms enabling seemingly intelligent behavior might also be the source of fabricated outputs.

cs.AIarxiv:2608.20041v1Lead article

A three-dimensional typology of agency for advanced AI systems

Willem Fourie

his paper introduces a novel three-dimensional typology to categorize the agency of advanced AI systems. It distinguishes agency based on its nature (moral/legal), mode (individual/collective), and locus (human/non-human). This framework allows for a more nuanced understanding of AI agency, particularly non-moral forms, and classifies potential instantiations as conventional, contested, or controversial.

cs.AIarxiv:2608.19902v1Lead article

Bringing analytic rigor to agentic AI for science: The Brain Researcher platform for neuroimaging data analysis

Zijiao Chen, Nicholas Lu, Xinhui Li, Jocelyn A. Ricard, Ce Ju

his paper introduces Brain Researcher, an agentic AI platform designed to bring analytic rigor to scientific AI. Its core method involves operating within a researcher's environment under strict rules for admissible analyses, checks, and claim scope. The key contribution is demonstrating how this framework significantly improves tool selection accuracy and verifiable grounding, while also enabling the identification of analytic-choice sensitivity and facilitating robust scientific review of AI-generated claims.

Brain Researcher: workspace-centric infrastructure for auditable neuroimaging research. Brain Researcher runs inside the researcher’s existing computational environment and exposes neuroimaging analyses as structured, auditable operations: every choice, check, and input is recorded as it happens, so that a frozen record of the completed analysis can be read and audited by someone other than the person who ran it, without re-executing it. (a) The tool ecosystem: established neuroimaging software for preprocessing, modeling, meta-analysis, machine learning, quality control, and reporting, each represented by a machine-readable specification and executed in a version-pinned container. (b) Each specification declares its inputs, outputs, parameters, version, evidence anchors, and validation rules; the rule checker tests every proposed call against these clauses before it runs, and records which clauses passed or failed. (c) The episode workflow: the researcher frames a question and approves the plan at the commitment gate, valid actions are dispatched to version-pinned executors, and the resulting audit bundle, containing the committed plan, tool versions, evidence consulted, artifacts, logs, provenance, and the checks each claim passed, feeds the review layer, which writes condition-tagged claims back to memory. This audit bundle is what makes an analysis auditable: a completed run is a fully inspectable research object rather than a one-off result, exported as a compact claim card a reviewer can reopen field by field. Methodological judgment remains the researcher’s; the system makes it visible at each stage.
Brain Researcher: workspace-centric infrastructure for auditable neuroimaging research. Brain Researcher runs inside the researcher’s existing computational environment and exposes neuroimaging analyses as structured, auditable operations: every choice, check, and input is record…
cs.AIarxiv:2608.21099v1Lead article

A2DINOv3: Rethinking Multi-Modal Object Detection via Socialized Collaboration

Jiekang Feng, Zhihe Fan, Yunqi Zhu, Xinjie Yao, Yueying Zhang

his paper proposes A2DINOv3, a multi-modal object detection framework that addresses the challenge of fusing heterogeneous modalities like RGB and infrared. It introduces a "Socialized Collaboration Protocol" where each modality acts as an independent expert, selectively exchanging complementary information to preserve pre-trained representations and avoid redundant fusion. This approach enhances robustness in challenging environments by enabling more effective multi-modal understanding.

Social interdependence in human society versus socialized interdependence in multi-modal object detection.
Social interdependence in human society versus socialized interdependence in multi-modal object detection.
cs.AIarxiv:2608.23400v1Lead article

Adaptive Item-based Collaborative Structures via Noise Rescheduling in Diffusion for Generative Recommendation

Jiaqi Wang, Tianying Liu, Heng Chang, Jihong Guan, Wengen Li

his paper introduces ANR-DiffRec, a generative recommendation framework that enhances discrete diffusion models. It addresses the limitation of existing methods by explicitly incorporating item-based collaborative filtering information. The core contribution is a novel noise rescheduling strategy that leverages item co-occurrence to adapt the diffusion process, leading to more accurate recommendations by better capturing item relationships.

Figure 1. Illustration of the proposed item-based adaptive noise rescheduling strategy. (a) Existing diffusion-based recommendation models employ a uniform noise schedule, assigning identical denoising weights to masked tokens regardless of their contextual dependencies. (b) Our method dynamically adjusts the denoising weight for each token by jointly considering two complementary signals: (1) local recoverability estimation, and (2) behavior-aware dependency modeling. The final denoising weight is obtained by combining these two signals, enabling structure-aware diffusion training.
Figure 1. Illustration of the proposed item-based adaptive noise rescheduling strategy. (a) Existing diffusion-based recommendation models employ a uniform noise schedule, assigning identical denoising weights to masked tokens regardless of their contextual dependencies. (b) Our …
cs.AIarxiv:2608.23525v1Lead article

EarthVerse: Benchmarking Scientific Agents Across Dynamic Earth Systems and Natural Hazards

Zhiqing Cui, Xinxiang Yin, Yihong Tang, Xinglang Zhang, Yuanzhe Hu

arthVerse is a benchmark designed to evaluate scientific agents on their ability to analyze dynamic Earth systems and natural hazards. It provides 405 reproducible tasks using heterogeneous data from 199 documented events, assessing agents' capabilities in evidence selection, calculation, reconciliation, and provenance preservation. The contribution lies in its comprehensive evaluation framework, which includes executable ground truth and task-specific rubrics, allowing for a nuanced assessment of agent performance and identification of failure points.

Coverage and model landscape. Task and answer-unit coverage across hazards and capabilities (left); mean answer-unit accuracy and token use across 25 systems (right).
Coverage and model landscape. Task and answer-unit coverage across hazards and capabilities (left); mean answer-unit accuracy and token use across 25 systems (right).
cs.AIarxiv:2608.23248v1Lead article

Future Querying: Can LLMs Serve as Implicit Medical World Models?

Siri Willems, James Butterworth, Lore Goetschalckx, Peter Vrancx, Philippe Modard

his paper introduces "future querying" to assess if LLMs can act as implicit medical world models. The core method involves using LLMs to answer time-indexed questions about a patient's future based on unstructured clinical notes. The key contribution is demonstrating that this endpoint-agnostic approach allows a single, locally fine-tuned LLM to handle diverse queries without retraining, showing promise for privacy-preserving medical AI.

The future querying paradigm. A patient timeline p p is partitioned by a virtual present T ^ \( \hat{T} \) into an observed history and a hidden future. Given the historical context and a flexible, time-indexed clinical query q k q_{k} , we investigate whether an LLM can serve as an implicit medical world model to predict the correct answer a k a_{k} derived from the patient’s actual future timeline.
The future querying paradigm. A patient timeline p p is partitioned by a virtual present T ^ \( \hat{T} \) into an observed history and a hidden future. Given the historical context and a flexible, time-indexed clinical query q k q_{k} , we investigate whether an LLM can serve as…
cs.AIarxiv:2608.23397v1Lead article

MediSkill-Evo: Process-Constrained Self-Evolution for Evidence-Grounded Clinical Interaction

Ruoyu Wu, Shenfu Xie, Yinqian Sun, Haibo Tong, Feifei Zhao

ediSkill-Evo is a clinical agent that improves diagnostic accuracy by evolving its process knowledge without retraining its core model. It achieves this by separating and managing different types of knowledge (skills, rules, schemas, procedures) and using a novel "Process-Constrained Preference Harness" to ensure actions are grounded in evidence and adhere to safety constraints. This approach allows the agent to learn and adapt its reasoning process, leading to more reliable and evidence-based clinical interactions.

Figure 1. Online inference and offline learning and governance in MediSkill-Evo. Left: the online pipeline retrieves four-bank context, generates and verifies candidate actions, executes the selected action, and incorporates environment feedback. Right: completed trajectories are reflected into typed memory operations, validated for label/evidence leakage, controller-defined safety, support, and replayability, and published as the next memory snapshot. Two equally sized MediSkill-Evo diagrams separated by a vertical dashed line. The left panel presents the seven-stage online inference pipeline, and the right panel presents the six-stage offline learning and governance pipeline.
Figure 1. Online inference and offline learning and governance in MediSkill-Evo. Left: the online pipeline retrieves four-bank context, generates and verifies candidate actions, executes the selected action, and incorporates environment feedback. Right: completed trajectories are…
§ III

Daily Issues This Month

2026-08-02 to 2026-08-31 30