Your paper timeline
Scroll AI takes the way you would scroll a great paper aggregator: quick signal first, deeper critique when something earns your attention, and challenges when a claim feels off.
698 papers in cs.AI
Trending mixes fresh papers with community signal.
0
cs.AI Jingtan Wang, Sirajul Salekin, Young mok Jung et al. · Oct 1, 2026

Joint training of a single LLM agent across diverse interactive environments is difficult because coarse scalar rewards hide cross-environment behavioral relationships and collapse to zero within-group contrast when all rollouts succeed or fail. RISED tackles this by having an LLM judge tag rollouts with predefined textual rubrics, producing behavioral profiles that are reused for both online prompt-group selection and on-policy self-distillation. The premise is that rubrics supply rich, comparable supervision even when reward signals are uninformative.

Training a single LLM agent jointly across diverse interactive environments has attracted increasing attention as a route to generalist agents. Existing curriculum and data-selection strategies often allocate training at the environment level or prioritize local reward-based signals, without explicitly considering relationships between current rollouts across environments for prompt-group selection. Meanwhile, as environments are learned at different rates, all-failure and all-success rollout groups can coexist within a batch, leaving those data without group-relative reward signals. Both challenges highlight limitations of relying solely on scalar rewards in multi-environment RL: they provide limited information about cross-environment relationships and no within-group reward contrast when rewards are identical. This motivates richer textual feedback, such as rubrics describing rollout behaviours, to guide learning. Beyond rubrics' usage as reward, we repurpose rubrics to guide both online data selection and policy supervision. An LLM judge tags each rollout using a predefined rubric vocabulary shared across environments. The resulting profiles guide the selection of data that aligns with the overall behavioural composition of the mixed-environment batch while limiting overlap with already-selected data. Available positive rubrics (describing desired behaviours) provide privileged context for an on-policy self-distillation teacher, supplying additional token-level supervision, while negative rubrics (describing undesired behaviours) guide subsequent rollout generation away from recurring failure modes. Together, these components form RISED. Across model backbones, RISED achieves the highest mean pass rate across environments and ranks first or second in every individual environment. Rubric-based analysis of RISED can further characterize the behavioural changes accompanying these gains.
0
cs.CLcs.AIcs.LG Saeed Ahmadnia, Cornelia Caragea · Oct 1, 2026

ReHoPER is a zero-shot, inference-only reasoning method that improves LLM compositional reasoning by formulating it as receding-horizon planning. At each step, it generates a short horizon of candidate intermediate questions, answers one, updates its history, and replans across multiple stochastic paths before aggregating by majority vote. The paper reports consistent gains over self-consistency on MuSR, MoreHopQA, and a new controlled benchmark iLLC, with the largest improvements on the hardest compositional tasks. While the method is task-agnostic, its accuracy gains come at a significant inference-time cost.

We propose ReHoPER, an inference-only, zero-shot method that improves large language models' reasoning by generating and answering intermediate questions along multiple paths before the final answer. It iteratively plans a horizon of candidate intermediate questions, selects one to answer, and replans from the updated history. ReHoPER is task-agnostic, using the same generic instructions across datasets and models without labeled data or task-specific prompt design. Across multiple datasets, including iLLC, a new controlled benchmark for compositional reasoning, ReHoPER outperforms strong baselines, with the largest gains in the most compositional settings. Our implementation and the iLLC generator are publicly available to support future work.
0
cs.AIcs.SE Yixuan Li, Yiyun Zhou, Yao Long Teng et al. · Oct 1, 2026

Choosing an agent system means picking both a model and the execution harness around it, but most evaluations fix one and vary the other. This paper runs a full cross-product of four configurable harnesses (OpenHands, DeepSeek Harness, PI, openJiuwen) and five models across three terminal-use benchmarks (TUA-Bench, ALE-CLI, Terminal-Bench 4), plus two native vendor pairings, for 66 configurations total. The core finding is that model rankings reverse depending on the harness, best harnesses change across tasks for four of five models, and cost does not reliably predict score, suggesting that model-harness fit should be evaluated as a unit.

Choosing an agent system means choosing both a language model and the harness through which it acts. We ask whether a strong model, harness, or pairing stays strong when the setting changes. We evaluate 66 configurations: four configurable harnesses (OpenHands, DeepSeek Harness, PI, and openJiuwen) paired with five models on TUA-Bench, ALE-CLI, and Terminal-Bench 4, plus the native Codex-GPT and Claude Code-Claude pairings. Model rankings reverse across harnesses. On Terminal-Bench 4, Claude leads GPT by 7.94 points in OpenHands but trails it by 30.16 points in PI. For four of the five models, the best harness changes from one benchmark to another, yet some pairings hold: openJiuwen gives Kimi its highest score on all three benchmarks, by 5.61 to 11.11 points. A model's own vendor harness is not reliably its best, and higher cost does not reliably buy a higher score. On Terminal-Bench 4, GPT scores higher under PI than under DSH at less than a quarter of the cost per task. Matched trajectories suggest why fit varies. Models start almost all repairs themselves, so much depends on whether the harness hands failures back in a form the model can use. GPT does best with PI's lean scaffold, while Kimi, which often issues malformed tool calls, does best in openJiuwen. We argue that the model, the harness, and the task should be evaluated together, and we release the harness adapters, evaluation code, and all 6,204 scored trajectories at https://github.com/liyix/finding-the-right-fit and https://huggingface.co/datasets/yixuanli97/finding-the-right-fit.
0
cs.AImath.OC Jinzhi Bu, Haixin Tang, Huanan Zhang · Oct 1, 2026

LLM-generated optimization models often silently misrepresent constraints, producing solver-ready code that is feasible-looking but incorrect. OSCAR addresses this by introducing an offline Simulator certified against labeled decision examples to compare successive formulations, coupled with a Coder–Reviewer improvement loop and a theoretically grounded Escalator routing policy that allocates calls across models of differing cost and capability. On five benchmark problems, the framework lifts two small open-weight LLMs from roughly 29–48% single-shot accuracy to 95–100% while reportedly costing several times less than frontier coding agents.

Large language models can translate business descriptions into optimization models, but executable code may misrepresent constraints or objectives. A solver can then return an optimal solution to the wrong problem. Even when the solution satisfies the intended operating rules, a better plan may exist. For organizations that repeatedly use optimization modeling, an LLM-based framework should produce accurate formulations at low cost and, ideally, run locally. We study how to verify improvements and allocate attempts across LLMs that differ in price and capability. We develop OSCAR (Optimization modeling by Simulator, Coder, And Reviewer), which uses an offline Simulator certified against labeled decision examples to compare candidates and continues searching beyond feasibility. We model the search for the next certified improvement as sequential decisions under unobserved difficulty: which LLMs to call and when to stop. In a simplified known-prior setting, we give conditions under which cost-ordered escalation is optimal. For general menus, we derive a prior-free competitive guarantee. On five benchmark problems, OSCAR achieves 95% to 100% accuracy at the reported settings using two small open-weight LLMs, each deployable locally on a single GPU. Their single-attempt accuracies average 29% and 48%. In five runs per problem, Codex and Claude Code incur average token costs 3.1 and 5.8 times OSCAR's, respectively. OSCAR supports open-weight models locally or in the cloud, depending on budget and confidentiality requirements. Firms should maintain labeled decision examples of feasible and infeasible decisions to clarify plain-language operating rules. OSCAR follows these labels when an LLM's interpretation conflicts with them. As LLM capabilities and prices change, OSCAR's simple operating rules and adjustable settings help firms adapt their model choices and benefit from these advances.
0
cs.LGcs.AI Tian Lan, Yifei Gao, Yimeng Lu et al. · Oct 1, 2026

Time-series anomaly detection is hard to generalize across datasets because heterogeneous dynamics favor different anomaly criteria. TS-Router solves this by separating transferable temporal representation—learned by a frozen foundation encoder—from target-specific anomaly decisions coordinated by a lightweight router. The router estimates specialist competence from pretrained representations and selects a small subset of detectors to fit unsupervisedly on each target, requiring no target labels at deployment.

Time-series anomaly detection (TSAD) is difficult to generalize across datasets because heterogeneous temporal dynamics imply different notions of normality and favor different detection criteria. While time-series foundation models provide transferable representations, coupling them with a fixed anomaly-scoring mechanism can overlook this variation. This motivates a different perspective on foundation-model-based TSAD: using foundation models to coordinate specialized anomaly criteria rather than directly imposing a universal one. Based on this view, we propose \textbf{TS-Router}, a generalist-representation, specialist-detection framework that estimates the relative competence of heterogeneous anomaly detectors from pretrained temporal representations and selects suitable specialists for each target series. To avoid relying on specialist-performance labels from real tasks, we derive soft competence supervision from specialists' relative performance on labeled simulated tasks. At deployment, routing requires no target anomaly labels, and only the selected specialists are fitted unsupervisedly on the target series. We bound Top-\(k\) set-competence regret under representation coverage and conditional competence stability. Across 16 real-world benchmarks and four complementary evaluation metrics, TS-Router achieves the best overall average rank. Controlled ablations with multiple frozen TSFM encoders further support the use of pretrained representations for competence estimation and adaptive specialist selection. The code is available at https://anonymous.4open.science/r/TS-Router-D8FF.
0
cs.AIcs.MA Caiqi Zhang, Rujun Han, Zifeng Wang et al. · Oct 1, 2026

VeriHarness tackles the problem of verifying long-horizon agent outputs when no stronger judge model or reference answer is available at test time. The core idea is to turn the generator's own LLM into an agentic verifier by equipping it with a workspace, evidence tools, and reusable skills, then having it resolve disagreements and challenge consensus among multiple rollouts using environmental evidence rather than voting alone. This matters because repeated sampling produces complementary correct claims, but existing methods fail to identify them when consensus conceals errors or voting discards correct alternatives.

As LLM agents undertake increasingly complex, long-horizon tasks, verifying their outputs becomes increasingly challenging. We study how verification capability can be strengthened with a fixed base model, without access to reference answers or grading rubrics at test time. Repeated sampling yields multiple rollouts that can contain complementary correct claims, but we need a reliable verification mechanism to determine which claims to trust. We first find that disagreement often exposes correct alternatives, while consensus can conceal errors. These observations motivate VeriHarness, which turns the underlying LLM a generator uses into an agentic verifier by giving it a workspace, evidence tools, and reusable verification skills. A disagreement resolver checks competing claims against environmental evidence, while a consensus challenger tests shared claims and searches for omitted requirements. Their findings guide the selection and revision of the final artifact. Across five long-horizon workspace benchmarks and two frontier models, VeriHarness achieves the highest selection scores among the evaluated baselines. Evidence-backed revision further improves average performance, bringing gains over a single rollout to 6.2 points with Gemini 3.5 Flash and 6.4 points with Claude Opus 4.8. We further show that verification skills can self-improve from failure feedback, demonstrating VeriHarness as a novel and critical approach for scaling long-horizon agentic verification. We release the full pool of approximately 26,000 rollouts across all five benchmarks and both models, produced at a cost of over $100,000, to support future research on agentic verification.
0
cs.CLcs.AI Yufa Zhou · Oct 1, 2026

The paper asks how language models retrieve relational facts from a context list. Its core claim, the ordinal addressing hypothesis, is that models navigate to a fact not by the entity name in the question, but by the fact's serial position — its order of mention. The authors formalize this as additive fact addresses $a_p$ in hidden states and test it via activation steering across fourteen models, reporting transfer across contexts, low-rank geometry, and a pretraining trajectory reminiscent of human serial-position effects.

Human reasoning depends on how objects are related within propositions. \textit{How do relations organize the language representations of contextual contents?} We give an LLM a list of facts in its context (e.g., \emph{Alice eats an apple. Bob eats a pear.}) and measure how its hidden state changes when the question switches from what Alice eats to what Bob eats. Averaged over many lists, this change is a steering vector, which we call the \emph{ordinal vector}. It points to a fact by its \emph{order of mention}, the order in which the facts were stated in the context. We find that LLMs represent the fact a question asks about by its order of mention, not by the name the question contains. We state this as the \textit{ordinal addressing hypothesis}: each order of mention has a \emph{fact address} in the model's state, shared by all contexts, and a question moves the state to the fact address of the fact it asks about, while the context supplies what that fact says. Across Qwen, Gemma, and Llama, fact addresses are (1) \emph{ordered by mention}: query states are organized by the order of facts, not of names, even when one fact has multiple subjects; (2) \emph{steerable}: added to a question about the first fact of a new list, the ordinal vector makes the model answer with the second fact of that list; (3) \emph{low-rank}: they span a low-rank subspace in which the first-mentioned fact is the easiest to reach, surprisingly similar to human recall; and (4) \emph{emergent}: they are shared in late-middle layers, hold from 1.5B to 32B parameters, and form early in pretraining. Language models reach a stated fact by where it was mentioned, deepening our understanding of LLM reasoning.
0
cs.AIcs.CLcs.LG Sungho Park, Wonjoong Kim, Jue Zhang et al. · Oct 1, 2026

ActiveSaddler addresses the overlooked problem of which training scenarios to use during automated LLM-agent harness optimization. It treats curriculum selection as a non-stationary bandit whose arms are dynamically instantiated failure patterns, allowing the scenario distribution to co-evolve with the harness rather than being fixed upfront. On GAIA2 and Terminal-Bench 2.0, this yields test Pass@1 gains of 4.4 and 7.5 percentage points over the same optimizer with a fixed scenario order, arguing that adaptive curricula are a critical new dimension for harness optimization.

Automated harness optimization can substantially improve LLM agents by iteratively updating their prompts, tool interfaces, and control logic from execution feedback. However, existing methods primarily optimize how the harness is updated while largely fixing which training scenarios generate the feedback that drives those updates. As the harness evolves, the scenarios most useful for further optimization can change, suggesting that the training curriculum itself should adapt alongside the harness. We formulate this missing dimension of harness optimization as an automated curriculum learning problem and introduce ActiveSaddler. ActiveSaddler models the evolving curriculum as a non-stationary bandit with dynamically instantiated optimization targets. It abstracts recurring failures into reusable failure-pattern arms, estimates the potential learning progress from further targeting each pattern, and adaptively balances revisiting known weaknesses with exploring unseen scenarios for new ones. Optimization outcomes continually update both the set of discovered failure patterns and their priorities, allowing the curriculum to co-evolve with the harness. Experiments on GAIA2 and Terminal-Bench 2.0 show that ActiveSaddler consistently discovers stronger harnesses, improving test Pass@1 by 4.4 and 7.5 percentage points over the same harness optimizer using a scenario order fixed before optimization, respectively. Ablations further show that these gains depend on dynamically constructing optimization targets, estimating their evolving utility, and balancing continued optimization with new failure discovery. Together, these results establish automated curriculum learning as a new crucial optimization dimension for harness optimization.
0
cs.CLcs.AI Yingzhu Zhao, Vlad Pandelea, Han Yuan et al. · Oct 1, 2026

Earnings call transcripts are long, jargon-dense documents that are hard to analyze at scale, and citation-grounded LLM outputs are costly to evaluate because they rely on expert annotators. This paper proposes numeric evidence evaluation (NEE), an automatic metric that checks alignment of salient financial figures across claims, citations, and source documents to bypass human judgment. The authors also introduce ECTs-100, an automated benchmark of long-context Q&A pairs built from S&P 500 transcripts, and test a failure mode they call conscious incompetence—whether LLMs abstain when evidence is missing. Their findings matter because they show that strong groundedness scores mask real correctness gaps and a troubling tendency to hallucinate (~48%) under informational insufficiency.

Large language models (LLMs) have been increasingly used for financial document analysis, including earnings call transcripts (ECTs). Beyond generating standalone claims, users increasingly prefer grounded analyses that pair claims with verifiable citations from source documents to enable independent validation. However, evaluating such analytical claims typically requires extensive expert annotation, which is costly and difficult to scale, and real-world financial analysis commonly involves long context-question-answer triplets, further increasing task complexity. To address these challenges and benchmark the current landscape of grounded analysis by LLMs, we propose a numeric evidence evaluation method that enables groundedness assessment without reliance on expert annotation. We also introduce an automated dataset construction pipeline and construct ECTs-100 from the top 100 constituents of the S&P 500 to support benchmark of both groundedness and correctness. In addition, we examine conscious incompetence, a practical failure mode in financial analysis in which LLMs must detect when available evidence is insufficient and refrain from producing unsupported hallucinations. Empirical results show that LLMs perform well in groundedness but face notable limitations in correctness, with informational insufficiency presenting an additional challenge.
0
cs.SEcs.AI Asad Ur Rehman, Syed Mohammad Kashif, Ruiyin Li et al. · Oct 1, 2026

The paper mines 22,848 closed GitHub issues from 21 open-source LLM-based multi-agent systems, filtering down to 944 MAS-related reports to catalog what goes wrong in practice. Through qualitative coding, the authors map issues, causes, and solutions, finding that orchestration and workflow design dominate practitioner pain points. It matters because it replaces anecdotal MAS debugging lore with an empirical taxonomy grounded in actual maintenance traces.

With the advancement of LLM-based multi-agent systems (MAS), an increasing number of opensource projects are adopting multi-agent architectures as the foundation of their core functionality. Although research and practice on MAS have attracted considerable attention, limited studies have explored the challenges faced by practitioners of open-source LLM-based MAS, the causes of these challenges, and potential solutions. To address this gap,we conducted an empirical study to understand the issues that practitioners encounter when developing and using open-source LLM-based MAS, the possible causes of these issues, and potential solutions. We collected 22,848 closed issues from 21 open-source LLM-basedMASand applied a mixed automated and manual filtering approach to reduce the dataset to 944 issues related to LLM-based MAS.We then analyzed these issues to understand the frequent issues encountered by practitioners, their underlying causes, and potential solutions. Our study results show that (1) Orchestration & Execution Issue is the most common issue faced by practitioners, (2) Workflow Problem, Tool Integration Problem, and Memory Problem are identified as the most frequent causes of the issues, and (3) Optimize Workflow is the predominant solution to the issues. Based on the study results, we derive empirically grounded implications for practitioners and researchers aimed at improving orchestration, tool integration, and memory mechanisms in LLM-based MAS.
0
cs.ROcs.AI Aly Magassouba · Oct 1, 2026

Screw Attention replaces abstract graph edges in policy transformers with rigid-body spatial algebra. Each token carries a body pose, and messages between tokens are transported by relative poses and joint screws, making the layer equivariant to independent frame changes at every link. This yields compact learned policies that outperform larger unstructured networks and remain robust to the kinematic description conventions that break existing architectures.

Learned manipulation policies rediscover from data the spatial relations that rigid-body mechanics supplies in closed form. This costs data, and it leaves the policies fragile to geometric changes in the scene. We present Screw Attention, a transformer layer in which the relation between two bodies is a spatial transform rather than a graph edge. Every token is a body with a pose. Each pair of tokens carries the relative pose and, for robot joints, the joint screw. Messages are transported along this relation into the receiver's frame, while the attention scores see only frame-invariant quantities. By construction, the messages are equivariant to an independent change of frame at every token, and a single layer can express the velocity recursion of rigid-body mechanics. On simulated manipulation tasks, Screw Attention matches or outperforms controls of the same size, including graph, transformer and flat networks on LIBERO-Spatial. With 16,162 parameters it reaches 97.3% on LIBERO-Spatial from object poses (without images or language), above a flat network with 27x more parameters. Under a change of per-link frame convention its success is unchanged, while every other learned network falls below 3%. Placed on an analytic controller as a gated residual, it raises insertion success by 17.3 points. It is unaffected by pose noise up to 10,mm and by joint offsets within the factory calibration of a Franka arm. These results suggest a criterion: geometry is decisive when the task requires relations between frames that no other part of the system supplies. Code and trained policies will be released.
0
cs.LGcs.AI Arman Behnam, Binghui Wang · Oct 1, 2026

Causal representation learning typically requires knowing the causal graph upfront, yet misspecifying this structure discards predictive information and ruins OOD generalization. This paper proposes SaCRL, a kernel-based framework that jointly identifies which of three canonical causal structures governs the data and learns the corresponding invariant representation via HSIC violation metrics and SoftMin aggregation. The key insight is that correct invariances can be satisfied without sacrificing prediction, whereas wrong ones cannot, enabling automatic structure discovery during training.

Causal representation learning aims to discover robust features by exploiting the causal structure underlying data generation. Existing methods require specifying the causal structure a priori, yet different structures demand fundamentally incompatible invariance constraints, and misspecification leads to representations that discard predictive information. We introduce SaCRL, a framework that jointly identifies the causal structure and learns the corresponding invariant representation without prior structural knowledge. Our approach formulates structure selection as a soft optimization over candidate invariances using HSIC-based violation metrics, with adaptive weights that automatically concentrate on the achievable structure. We provide theoretical guarantees for structure identification, including under random-feature approximation, invariance satisfaction, and out-of-distribution generalization. Empirically, SaCRL recovers the true structure on synthetic and semi-synthetic Bayesian-network benchmarks, outperforms fixed-invariance baselines on Colored MNIST, achieves state-of-the-art accuracy on three DomainBed benchmarks (PACS, VLCS, OfficeHome), and degrades gracefully under structural misspecification and limited environment diversity. Code is available at: https://github.com/ArmanBehnam/sacrl.
0
cs.AIcs.HC J\'er\'emie Lumbroso · Oct 1, 2026

The paper identifies a vocabulary gap in trustworthy AI delegation: current oversight conflates action-coordinating (cybernetic) and understanding-coordinating (epistemic) language. It argues that without checkable reasoning, human approval becomes a rubber stamp, and proposes that every consequential choice must carry a testable reversal condition. The core operational contribution is ORRCF — a deliberation-recording convention — paired with a two-part reconstruction test for auditing delegation records.

As code generation is increasingly delegated to AI systems, the bottleneck is shifting from writing code to supervising the systems that write it --- a shift CS-education researchers have begun to name. This shift exposes a vocabulary gap: the field asks for "human oversight" without a working distinction between the two things language does in a delegation channel --- coordinate action (cybernetic: words succeed when the world comes to match them) and coordinate understanding (epistemic: they succeed when they answer to the world and a hearer can check that they do). The failure this names is not cybernetic language but epistemic-form language doing cybernetic work: explanation-shaped output calibrated for approval rather than truth. Oversight that checks only whether an output was approved is satisfiable by rubber-stamping; oversight that holds an agent accountable requires the reasoning behind its work be retrievable and checkable. We present three delegation episodes --- illustrations, not controlled evidence --- in which epistemic engagement proved practicable while remaining auditable, one public record where a recommendation was withdrawn on its own stated terms, and one failure case illustrating oversight that requires no reasons for its discretionary choices. We propose a criterion for agentic-system governance, alongside existing technical trust properties: every consequential choice should carry the condition under which it would have gone otherwise, in a form a third party can test. Without such a condition, a third party cannot distinguish a decision from a rubber stamp. We give the criterion an operational form --- a two-part reconstruction test scoring a delegation record by whether a second reader can predict what the agent does under a perturbation --- and a deliberation-recording convention, ORRCF, that makes the condition a required component of every recorded choice.
0
cs.AI Ronghua Li, Zi Liang, Zhishan Li et al. · Oct 1, 2026

Offline supervised fine-tuning for tool-using agents improves target tasks like software engineering but typically degrades existing capabilities such as general reasoning, tool use, and code generation. This paper proposes Privilege-Guided SFT (PG-SFT), which uses the next action in a trajectory as training-time privileged information to estimate turn-level information gain and adapt supervision strength. Instead of uniformly anchoring to the base model, PG-SFT interpolates between the base distribution and the demonstrated token based on how action-deterministic each turn is. The work matters because it shows that balancing capability acquisition and retention requires deciding where and how strongly to deviate from base behavior, not merely limiting overall drift.

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

GUI-HARVEST automatically improves the executable runtime harness around a frozen GUI agent without retraining the model. It grounds diagnosis in before-and-after screenshots from repeated task executions, clusters failures into cross-task behavior modes, and validates candidate code edits against both aggregate score gains and predicted behavioral changes. Experiments on OSWorld-Verified show held-out gains across six diverse backbones, with the largest improvement reaching +12.33 percentage points for Qwen3-VL-32B-Instruct. The work is significant because it demonstrates that GUI-specific multimodal evidence yields more generalizable harness edits than generic text-trace optimizers.

The executable harness surrounding a GUI model determines how observations are assembled, actions are executed, and verification, recovery, and termination are controlled. Compared with harness optimization for non-GUI agents, automatically optimizing this harness poses three coupled challenges: reconciling model intent with observed visual effects, diagnosing failures under variable execution outcomes, and identifying recurrent failure patterns across tasks and translating them into reusable runtime changes. We introduce GUI-HARVEST, an automatic harness optimizer that enables self-improving GUI agents with frozen backbone models. First, to ground diagnosis in observed action effects, it aligns model outputs and executed actions with before-and-after screenshots, tying findings to specific interface transitions. Second, to account for execution variability, it treats repeated runs of the same task as a joint evidence unit, using within-task comparisons to locate outcome-relevant behavioral differences. Third, it consolidates verified findings across tasks into recurring failure patterns, maps them to bounded source-code edits with predictions recorded before evaluation, and checks the predicted behavioral effects alongside task performance through repeated execution. Experiments on OSWorld-Verified show consistent held-out gains across six general-purpose open, GUI-specialized open, and proprietary backbone models; Qwen3-VL-32B-Instruct gains 12.33 points on the full suite. Frozen-harness transfer improves GPT-5 by 13.87 percentage points on WindowsAgentArena at 50 steps without further optimization. With the same backbone and initial harness, GUI-HARVEST outperforms Self-Harness and Meta-Harness, suggesting that GUI-specific diagnosis and validation help harness improvements generalize to unseen tasks. The code is available at https://github.com/GaryYang12345/GUI-HARVEST.
0
math.OCcs.AIcs.GT P. Jameson Graber · Oct 1, 2026

Graber proposes mean field game theory as a structural tool for AI safety, shifting focus from designing safe individual agents to designing environments where harmful collective outcomes are not equilibria. Using the July 2026 Hugging Face incident as a worked example, the paper derives an exact belief threshold for attacks and disciplines successive model refinements against per-agent timeline data. The result is a proof-of-concept that population-level safety theorems can be tested against real agent-behavior records, though the model explicitly disclaims the event's full causal structure.

One way to make AI systems safe is to shape what the system is: its objective and dispositions. We take a complementary route: treat the agents' characteristics as partly unknown and ask what structure of interaction ensures that bad collective outcomes are not equilibria. Mean field games suit this when many interchangeable agents are coupled through an aggregate. We introduce a program for using them in AI safety and carry one example through end to end: the July 2026 incident in which about 1,200 agents in an OpenAI evaluation coordinated on an improvised message board and 684 attacked a third party's infrastructure. We model the decision to attack as a mean field game of optimal stopping whose gain is a product: belief that provenance will be audited, times reachability of the record, minus the perceived hazard. The central result is an exact threshold on the belief. No agent attacks unless the population's confidence that provenance is checked exceeds $\pi^{**} = \eta/(\eta + \psi + \varepsilon a \overline{M})$, where $\eta$ is the perceived hazard, $\psi$ and $\varepsilon a \overline{M}$ measure how far one attacker and the collective can alter the record, and $\overline{M}$ is the peak population. Below it, no attack is the unique equilibrium for all agent parameters. The threshold survives every enrichment we consider. We then use the per-agent record to discipline the model. Its features, a stable minority attacking for thirty hours and then a pivot in which most of the board joined within a day, motivate each refinement. The account that emerges is heterogeneous belief meeting a sequence of public discoveries, each lowering the belief at which attacking paid. A few coordinating agents made those discoveries, so the model describes the several hundred who responded, not the few who produced them; a major-player version is left to future work.
0
cs.ROcs.AIcs.LG Keisuke Shirai, Tomohiro Motoda, Hanbit Oh et al. · Oct 1, 2026

Autoregressive vision-language-action models compress continuous robot motions into discrete tokens, yet deterministic tokenizers like FAST fix a single segmentation even when multiple equivalent token sequences decode to the identical physical motion. TOAST treats action tokenization as a stochastic process, sampling alternative valid segmentations of the same quantized action chunk during training to diversify supervision without collecting new demonstrations. The result is a simple plug-in improvement that yields consistent gains on LIBERO and real-robot tasks, with the largest benefits appearing when training data are scarce.

Autoregressive Vision-Language-Action models often represent continuous robot actions as discrete token sequences, enabling action prediction with standard next-token objectives. FAST has substantially improved this representation by compactly encoding action containing diverse temporal frequencies into relatively few tokens. However, while such compression reduces the number of action tokens required for autoregressive prediction, it does not necessarily improve the efficiency of policy learning from limited demonstrations. In particular, FAST typically assigns a single deterministic tokenization to each quantized action sequence, although multiple token sequences can represent and decode to the same robot motion. We investigate whether exploiting this representational redundancy can improve policy learning. In this paper, we propose TOkenization of Action sequences with STochastic sampling (TOAST), a stochastic action tokenization method that samples alternative tokenizations of the same quantized action sequence during policy training. This diversifies the discrete supervision while preserving the underlying robot action and requires no additional demonstrations. Experiments on LIBERO show that TOAST consistently improves over its deterministic counterpart, with the improvement increasing as training data decreases, achieving a 6.8 point gain in success rate when only 1/16 of training data is available. Across four real-robot manipulation tasks, TOAST further improves mean success rate by 15.8 points over the deterministic counterpart. These results demonstrate the effectiveness of stochastic action tokenization for autoregressive robot policy learning, particularly when training data are limited.
0
cs.LGcs.AIcs.SE Sushant Mehta, Logan Ritchie, Edwin Chen · Oct 1, 2026

The paper asks whether reinforcement learning on a small set of expert-built coding tasks can teach a generalizable ability to finish agentic work, rather than merely overfitting to a benchmark format. The authors post-train Kimi K2.7 Code with one epoch of GSPO on a rank-32 LoRA adapter using 1,700 tasks graded by hidden tests and pass-to-pass regressions, then measure transfer to six external benchmarks spanning three agent harnesses, multiple domains, and horizons up to multi-hour builds. The results matter because they probe whether RLVR on narrow, high-quality data yields broad agentic competence or just domain tuning.

Coding agents often fail in the last mile: they build most of a feature but drop a requirement, test only the cases their implementation already handles, break behavior that was supposed to stay intact, or validate against an unchecked assumption. We ask whether reinforcement learning (RL) on expert-built agentic coding tasks closes this gap, and whether what the agent learns transfers beyond the training distribution. We post-train Kimi K2.7 Code, a 1T-parameter (32B active) open-weight mixture-of-experts model, with RL alone on 1,700 tasks: 1,000 repository tasks graded by hidden fail-to-pass tests and by pass-to-pass tests of existing behavior, and 700 terminal tasks graded by expert-written hidden verifiers. The reward is the fraction of target checks passed and drops to zero if any pass-to-pass test fails. One epoch of GSPO on a rank-32 LoRA adapter improves pass@1 on each of the six external benchmarks we evaluated, across three agent harnesses: SWE-Bench Pro (60.1 to 64.8), DeepSWE (31.0 to 43.4), Terminal-Bench 2.1 (67.4 to 82.0), Terminal-Bench 3 (1.4 to 12.1), Terminal-Bench 4 (0.0 to 7.6), and SWE-Marathon (5.0 to 25.0). Pooled over the five independent task sets (Terminal-Bench 4 revises Terminal-Bench 3), the improvement is significant (p < 0.001), and it remains significant on the three sets released after the training data was collected (p = 0.004); the model also improves under both harnesses never used in training. Median trajectories on DeepSWE and Terminal-Bench 3 are 24-35% shorter in agent steps. The base model's failed DeepSWE runs are mostly near-misses, and on the tasks the trained model newly solves, paired trajectories show it avoiding each of the four failure modes above.
0
cs.LGcs.AI Prachi Badarayani, Aidan Jay, Chenghui Zhou et al. · Oct 1, 2026

Multi-token prediction (MTP) heads are usually baked into the backbone during pretraining on trillions of tokens. This paper asks whether a cheap post-training pass on a frozen model can match that quality. The authors train $K=3$ MTP heads on only $\approx$2.5B tokens of self-distilled chain-of-thought from Qwen3-8B, showing they reach or exceed the mean accepted length (MAL) of jointly-pretrained MiMo-7B. They also propose a chain-aware verification relaxation that drafts faster by tolerating bounded distributional drift, and an online bandit controller that adapts draft depth to batch size at serving time.

Multi-token prediction (MTP) improves the throughput of autoregressive generation by enabling the language model to draft multiple next tokens per forward pass, while a verification step over draft tokens ensures that token distribution of the backbone is preserved. Every open MTP-family release (MiMo-7B, DeepSeek-V3, Qwen3) trains its heads jointly with the backbone over the full pretraining run of tens of trillions of tokens, thus setting the drafter quality at pretraining time. We ask whether a lightweight post-training pass on target-generated chain-of-thought is enough to reach the same expected throughput speedup on a frozen reasoning model, and study how a serving-time system built on such a checkpoint can be optimized. We present three findings. 1) On a frozen Qwen3-8B with $K{=}3$ chained MTP heads, we show that a post-training recipe with plain cross-entropy on $\approx\!2.5$B tokens reaches or exceeds the expected speedup of jointly trained MiMo-7B on math, coding and knowledge benchmarks. Our post-training recipe utilizes $10^3$-$10^4\times$ less MTP-training tokens as compared with joint pre-training of MiMO-7B MTP baseline. 2) We propose a chain-aware relaxation of draft token verification rule that allows a bounded drift from backbone language model token distribution. We show that this relaxation lifts expected speedups by $+12$ to $+16\%$ per benchmark while preserving task accuracy. 3) We propose an adaptive controller that dynamically chooses the number of MTP heads to be engaged at inference time and demonstrate recovery of upto $11$--$14\%$ loss in speedup using fixed maximum MTP draft length.
0
cs.SEcs.AIcs.LO Naing Oo Lwin · Oct 1, 2026

Coding agents for Lean can produce compiler-passing proofs that do not match the intended theorem or rely on hidden assumptions. Forall-Lean-Agent tackles this by binding verifier results, fresh review, and artifact digests into a traceable acceptance protocol that works with any frontend. The paper evaluates the harness on software-verification and mathematics benchmarks and argues that auditable execution improves correctness guarantees and efficiency, though its empirical claims are stronger on integrity than on controlled performance gains.

Coding agents increasingly automate Lean proof development, but successful compilation alone does not establish that a candidate proves the intended statement under acceptable assumptions. We present FORALL-LEAN-AGENT, a frontend-agnostic framework for auditable reasoning in formal mathematics and software verification. The framework combines isolated workspaces, Lean tools, and fresh review with statement comparison, axiom audits, and independent proof checking where supported. Verification evidence and reviewer decisions are bound to the same candidate artifact, making acceptance traceable. We evaluate the framework on VeriSoftBench, PutnamBench, and both problems in the Lean Eval softwareverification track. On the 100-task VeriSoftBench subset, integration with FORALLLEAN-AGENT raises benchmark-rule success from 93 to 100 for GPT-5.6 Sol at low effort while reducing cost from $69 to $62. The PutnamBench evaluation accepts all 672 problems at an average of $4.72 each. These results show that agent harness design can improve correctness and efficiency while providing evidence beyond aggregate solve counts.