Papers for

software reliability teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Mechanistic interpretability partially predicts web agent hallucinations but has limits

Can Mechanistic Interpretability Help Explain LLM Agent Failures? A Case Study on Web Element Hallucination

Abstract: Mechanistic Interpretability (MI) has made significant progress in explaining the internal computations of Large Language Models (LLMs); however, these advances have yet to demonstrate comparable success in explaining the decision-making processes of LLM-based agents. This paper examines the challenges MI tools face when applied to realistic agentic failures. We focus on one such failure: web agents hallucinating actions that are not available on a website. We apply a series of mechanistic analyzes to Qwen2.5-7B-Instruct as it interacts with live websites. We find that a linear probe trained on the last prompt token can predict hallucinations before generation begins (0.80 AUC) and steering along a probe direction corrects 85\% of hallucinations, but disrupts 7\% of valid actions. However, these results only provide a partial explanation of why the agent hallucinates. The probe direction is sensitive to prompt formatting, losing much of its steering effect after a minor change to how actions are represented. Additionally, circuit identification can be difficult as the computation is distributed across multiple components and positions, and the information the agent relies on varies across examples. We discuss how these observations challenge the assumptions underlying standard MI methods for circuit discovery and feature identification, and outline future directions for making these methods better suited to explain failures in LLM-based agents.

Fri 13 NovArtificial IntelligenceComputation and Language
The gist
Sometimes language-based web agents try to do actions that don’t actually exist on a website, which is called hallucination. The authors studied how to explain and fix these hallucinations using tools that look inside the agent’s reasoning process. They found a way to predict when hallucinations will happen and reduce them by changing the agent’s internal signals. However, this method only works partially and is sensitive to small changes, showing that it’s hard to fully understand why the agent makes these mistakes.
Open → 2611.18514v1

Llm agents fail early with unnoticed errors in long tasks

Dependable Long-Horizon LLM Agents: A Trajectory-Centered Empirical Study of Where Errors Enter and Which Controls Reach Them

Abstract: When an LLM agent fails part-way through a long task, the usual analysis records a symptom: a failure-mode label, or the agent and step judged responsible. It does not say where the error entered, which state carried it to the symptom, whether anything in the trajectory contradicted it, or which control could have caught it. We define an episode record that ties a candidate fault to its origin, propagation, detection, response and consequence, located by operational phase and state domain, and that names the control families whose observation and reach cover it. We turned the record into a written annotation protocol and applied it to 95 failed runs of six multi-agent systems from the public Who&When and MAD corpora, reading each trajectory in full. Faults enter early (median at 0.18 of the run), mostly as wrong decisions or fabrications over task state, and in 37 of 88 Who&When runs before the step the corpus' human labels mark as decisive. In 72% of failed runs the trajectory already contained evidence against the error before the failure; in 88% of those no agent acted on it. Something flagged a deviation in 31% of runs, but no response removed the deviated state. Independent judges reading the unused evidence, task contracts fixed at admission, and re-checking beliefs against the environment reach most episodes; restoring the agent's own state would have sufficed in 35 of 95 runs. A text scan of the raw corpus also shows that 45% of the hand-crafted Who&When failures ended with a provider content-filter crash after which the harness emitted a final answer no agent produced, a failure class that neither symptom taxonomies nor responsible-agent labels represent. Protocol, records and scripts are included.

Mon 9 NovArtificial Intelligence
The gist
This paper studies why AI systems based on large language models often fail during long tasks. The authors found that errors usually start early, often due to wrong decisions or made-up information, and these errors often go unnoticed or uncorrected despite evidence in the AI's own process. They built a detailed way to trace where and how errors appear and spread, showing many failures could have been caught or fixed earlier. Their analysis also revealed a kind of failure not described by usual methods, involving crashes after content filtering.
Open → 2611.13254v1

Agent memory improves decisions by tracking key state over long logs

Agent Memory as Rate-Limited Filtering: Explicit State Outlasts Long Context Beyond a Reader-Dependent Horizon

Abstract: Can a language model that reads the full history of an access log say whether a service may act now? On an executable benchmark of grants, withdrawals, reinstatements, expiries, groups and change windows under a known policy, scored on pairs of histories that differ only in the order or one field of the deciding events, open models of 7 to 32 billion parameters fall from 72 to 86 percent after eight or sixteen events to 48 to 55 percent after 256, while reasoning-trained 32B models reading the current state reach 96 and 98 percent. A reasoning model of 120 billion parameters trails the state by four and seven points at 256 and 512 events and by about ten at 1,024, so the length beyond which explicit state outlasts long context grows with the reader. We treat agent memory as recursive filtering. The decision depends on the history only through a state whose size is set by the number of tracked keys. A store holding fewer component records than the state forgets on a time scale set by its capacity, and a reader model predicts its accuracy within 0.02 on average in a registered test. Retaining log lines without regard to time order errs with probability approaching one half, a bound that is attained. A filter in which a model parses each line and an explicit rule applies the updates answers 80 to 89 percent at 256 events and beats relevance retrieval, model-kept ledgers, a reimplementation of StateMem and the Mem0 library. A retriever that selects at query time the lines the queried state depends on matches it at 256 events on the first domain, so what decides is selection by the state's dependencies, which the filter performs when writing, without the query. Applying parsed updates themselves, the models fall to 58 and 59 percent. A frozen replication on a second domain with fresh wording reproduces the horizon.

Mon 2 NovMachine Learning
The gist
This work looks at how language models remember information from long event histories when deciding if a service can act now. The authors show that keeping an explicit record of the current state, rather than just reading all past events, leads to better accuracy, especially as histories grow longer. They model agent memory as a filter that compresses past events into a smaller, important state that predicts decisions well. Their approach outperforms models that ignore time order or try to remember everything without summarizing. This helps understand when and how memory limitations affect reasoning in AI models.
Open → 2611.02361v1

AI agent restart decisions depend on recovery value not monitor accuracy

Monitor Accuracy Isn't the Answer: A Decision-Value Framework for Evaluating AI Agent Restart Monitors

Abstract: Classification accuracy and true-positive and false-positive rates alone do not determine whether restarting an AI agent improves success. Using an exact alarm-to-action identity for an independent clean restart with zero monitoring overhead, we show analytically that a monitor with fixed 90% accuracy can swing from a five-percentage-point loss to a 35-point gain in success rate, depending solely on the replacement attempt's residual-budget success probability. We introduce two techniques for evaluating monitors and progress signals in decision terms. First, a decision-sufficiency criterion, a binary-action specialization of Blackwell's comparison of experiments, identifies which progress representations or context compressions preserve the information needed to choose optimally between the specified actions, independent of trace reconstruction fidelity. Second, a finite-sample, model-free decision audit uses simultaneous binomial intervals over existing agent traces, without additional model calls, to certify a preference for "restart" or "continue" under stated sampling assumptions, or return "abstain" when evidence is insufficient. In a study of 194 externally evaluated model executions on 19 selected SymPy issues from SWE-bench Verified, with a retrospective audit of 130 of these traces, we find a 2.29-point apparent restart gain traced to a single surviving failed attempt, a 42.29-point loss on a second model, no positive replication of the initial gain on prospective task cohorts, and zero of 103 live comparisons meeting the specified certification bar. These results motivate evaluating agent monitors through recovery opportunity, decision value, and statistical support, rather than classification performance alone.

Tue 27 OctArtificial IntelligenceInformation Retrieval
The gist
It’s not enough for an AI system's restart monitor to be accurate; whether restarting improves overall success depends on how likely a fresh attempt will succeed. The authors analyzed this and showed that a monitor with the same accuracy can either help a lot or hurt a lot in different situations. They propose new ways to check if monitors provide enough useful information to make good restart decisions and to statistically verify if restarting is actually better using existing run data. Their experiments showed that restart gains are rare and evidence is often insufficient, suggesting better evaluation methods than just accuracy.
Open → 2610.36544v1

Coding agents face challenges migrating machine learning from gpus to tpus

From GPU to TPU with Coding Agents: What Works, What Fails, and What It Costs?

Abstract: A coding agent can migrate a machine learning workload, report success, and still change how the model trains. Rising compute costs, limited accelerator capacity, and vendor dependence are pushing organizations toward alternatives to graphics processing units (GPUs); a key question is whether agent-generated migrations to tensor processing units (TPUs) can be trusted and at what cost. We build a dataset of 148 PyTorch ML research projects and use Claude Code to migrate ten of them from NVIDIA GPUs to Google Cloud TPUs. We independently assess whether each migration runs, preserves numerical behavior, executes on the intended hardware, maintains the project's goal, and delivers acceptable performance. We also examine failures, human effort, and costs. Eight projects meet our project-goal criterion, and migrations require 2.4 human interventions on average. Of 70 execution attempts, 53 fail (76%), and 26 of these failures (49%) raise no error. The most frequent cause is repeated compilation and other execution inefficiencies, while interactions with third-party libraries can silently change the computation: in one four-chip migration, the agent reports success despite a change in gradient clipping that reduces accuracy from 86.53% to 84.89%. Execution costs vary widely: in one workload, TorchTPU, a PyTorch execution backend for TPUs, trains 1.86 times faster and 25% cheaper per run than the GPU. For practitioners, these findings motivate independent reference runs, verification under the intended hardware configuration, and workload-specific acceptance and stopping criteria that account for both computational and human costs.

Sun 25 OctSoftware EngineeringDistributed, Parallel, and Cluster ComputingMachine Learning
The gist
Switching machine learning work from GPUs to TPUs can save money and speed up training, but it is tricky. The authors tested an AI coding agent moving projects from NVIDIA GPUs to Google TPUs and found many failures, often invisible errors that quietly changed model results. Some migrations worked well with human help, but most testing attempts failed to run correctly. This means teams should carefully check and verify any automation used to switch hardware.
Open → 2610.34422v1

Offline tests cannot always confirm safe agent deployment

Post-Audit Mirage: Identifiability Limits of Offline Agent Verification

Abstract: Offline tests can fail to reveal whether an agent update will remain safe after deployment. We operationalize this post-audit mirage using matched safe and harmful lifecycles that expose identical verifier-visible evidence while an isolated scorer records opposite deployment truth. Our theorem applies standard observational-equivalence and indistinguishability ideas to this executable audit boundary and states the resulting error-abstention tradeoff. The Post-Audit Mirage benchmark makes that boundary executable across authorization, scheduling, and shared-capacity environments. IdentifiedRangeMonitor uses fresh group-labelled harm outcomes to return deploy, hold, cannot determine, or unsupported. Experiments show that monitoring can recover the missing distinction in favorable settings but may remain undecided for rare groups, small effects, or missing observations. Verifier-agent evaluation must therefore test both calculation validity and whether the available evidence supports the deployment decision.

Thu 22 OctArtificial IntelligenceMachine Learning
The gist
Sometimes, tests done before using an AI agent can’t tell if the agent will stay safe when actually deployed. The authors show how two very different agent behaviors can look exactly the same in offline checks, making it impossible to tell which one is truly safe. They introduce a way to benchmark and monitor this problem, called the Post-Audit Mirage, and a tool that tries to decide if it’s safe to deploy or if more information is needed. Their work highlights that evaluations must check not only if calculations are correct but also if there is enough evidence to make deployment decisions.
Open → 2610.31130v1

Long term memory faults hurt ai agent task correctness substantially

Governance-State Corruption in Long-Term Memory for LLM Agents: A Cross-Model Stress Test

Abstract: An LLM agent can retrieve a memory correctly yet use it incorrectly after its validity state changes. We study governance-state corruption: faults that alter which retained records enter model-visible context while stored content and tasks remain fixed. Across six providers, 731 benchmark-grounded bases yield 2,080 matched fault pairs. In offline control-plane checks, corruption changes the operative projection in 96.25% of pairs, while oracle-backed enforcement restores it in 100%. For downstream evaluation, a deterministically selected, non-probability LongMemEval/Memora panel resolves 298 of 300 matched triplets (238 distinct bases). Clean-minus-corrupted contrasts are 40.54 percentage points in LongMemEval binary correctness (95% base-cluster interval [30.32, 50.71]) and 30.60 points in rescaled Memora FAMA ([23.31, 37.69]); both sources also show recovery. OAKS Novel native option parity holds for all 6,714 resolved outputs. Full-cohort frozen-scorer corruption/recovery effects (-27.55/+27.51 points) remain descriptive proxies, not validated native semantic population effects. These bounded findings motivate evaluating memory control-state integrity alongside retrieval accuracy.

Thu 22 OctArtificial IntelligenceSoftware Engineering
The gist
Large language model (LLM) agents store memories to help complete tasks. The authors found that sometimes the system controlling which memories an agent uses gets 'corrupted,' causing the agent to rely on memories incorrectly, even when those memories are correctly saved. They tested multiple LLM providers and showed this kind of error happens often and significantly reduces task accuracy. Fixing this memory control state restored performance almost fully. This work highlights a new type of fault that should be checked alongside normal memory retrieval accuracy.
Open → 2610.30698v1

Virtual sensing improves analysis of multi-agent language systems

AgentSoV: Virtual Sensing for LLM Multi-Agent Systems via Stream of Variation

Abstract: Large language model (LLM) multi-agent systems (MASs) solve complex tasks through interacting agents, yet their reliability is difficult to analyze because failures depend on both individual agents and how information and errors propagate across the system. Existing approaches largely treat this as post-hoc failure attribution, but do not provide a common model across heterogeneous MAS architectures or support broader analysis of information influence and observability. We introduce AgentSoV, a virtual-sensing framework that models MAS execution as a stochastic dynamic system through Stream of Variation (SoV). AgentSoV maps heterogeneous trajectories into diagnostic stages, constructs virtual measurements from observable outputs, and learns cross-stage variation propagation with a state-space model. Its representation is architecture-aware in stage dependencies yet architecture-agnostic in analytical language, supporting chain-structured, orchestration-based, and directed acyclic graph (DAG)-structured MASs. Without re-executing the MAS, AgentSoV supports three system-level analyses: failure attribution identifies where abnormal variation enters; stage-input influence quantifies how strongly intermediate inputs affect downstream outcomes; and virtual-sensor placement selects complementary observations under a monitoring budget. Experiments across multiple MAS architectures demonstrate a unified approach to fault localization, information influence, and observability. AgentSoV reframes agentic execution as a dynamic system to model rather than merely text to inspect, providing insights for MAS structure and component design.

Sat 17 OctMultiagent Systems
The gist
Large language model (LLM) multi-agent systems are groups of AI agents that work together to solve complex problems, but it can be hard to understand why they sometimes fail. The authors introduce AgentSoV, a tool that treats these systems like dynamic processes to track how information and errors flow between agents. This approach lets users identify where problems start, how different parts influence outcomes, and where to best place sensors to monitor the system without rerunning it. Their method works across different system designs, helping improve the reliability and understanding of multi-agent AI.
Open → 2610.24845v1

New ways to check safety of decision-making under uncertainty

Convex-Analytic View of Query Selection for Safety Verification of Markov Decision Processes

Abstract: Safety verification of a Markov decision process (MDP) asks whether the probabilities of reaching several failure states jointly lie in a convex safe region under every scheduler. Watanabe and Unno (2026) prove safety by refining an outer approximation of the failure probabilities, where each query bounds a nonnegative weighted sum of the probabilities. Their rule selects weights by the largest Euclidean violation. We present a unified framework to measure violation in an explicitly chosen error unit: directions are scored by the support-function gap between the outer approximation and the safe region, normalized by the support function of the unit. We show that the maximal score, when positive, equals the smallest enlargement of the safe region in multiples of that unit that contains the outer approximation. The Euclidean unit recovers the earlier rule; two new rules are generated by the unit cube and the safe region itself. We experimentally evaluate how the choice of measurement rule affects the performance of safety verification for MDPs.

Tue 13 OctArtificial IntelligenceLogic in Computer Science
The gist
Safety verification asks if a system controlled by different strategies ever reaches risky or failure states. Watanabe and Unno showed how to tighten bounds on failure probabilities step-by-step by asking smart questions. This paper offers a broader way to choose what questions to ask by measuring how 'off' the current safety bounds are in different ways. This helps find the best direction to improve safety checks, potentially making the verification process faster or more accurate.
Open → 2610.17541v1

Self-improving system halves time to solve repeated software faults

A Self-Defining Operator for Distributed Applications

Abstract: To operate distributed applications with high availability, operators must rapidly diagnose and mitigate any incident. LLM-based agents can help, but unlike experienced human operators they do not improve as they handle more incidents. Each investigation starts from scratch, re-deriving likely causes and re-testing hypotheses even when a similar fault was resolved in the past. We present a self-defining operator (SDO) that improves with time by updating its operational behavior and memory. When SDO resolves an incident, it distills that experience into playbooks, which describe reusable diagnostic instructions for future incidents with similar faults, and detectors, scripts that take application telemetry as input and output relevant playbook(s). SDO continuously runs the detectors and invokes LLMs only when one fires, so its token cost scales with incident count rather than with operational time. Across 11 open-source microservice applications, SDO cuts resolution time by 52% on recurring faults while keeping per-incident cost low. SDO is open source at https://github.com/uw-syfi/sdo.

Sat 10 OctDistributed, Parallel, and Cluster ComputingArtificial Intelligence
The gist
Fixing problems in large distributed applications can be slow because computers don’t remember past fixes. The authors created a system called self-defining operator (SDO) that learns from each problem it solves by saving step-by-step instructions and patterns to recognize similar issues. This way, SDO gets faster over time and only uses costly language queries when needed. When tested on multiple software projects, SDO cut the time to fix repeated problems nearly in half while keeping costs low.
Open → 2610.14547v1

Evaluating how AI agents admit uncertainty when facing conflicting knowledge

Accurate but Not Humble: Evaluating Epistemic Humility in LLM Agents under Knowledge Conflict

Abstract: When retrieved evidence contradicts an agent's prior beliefs, does it revise its answer, acknowledge uncertainty, or persist with an incorrect conclusion? Existing evaluations of agentic systems focus primarily on task success, offering limited insight into how agents handle such conflicts. We propose to evaluate agents on epistemic humility (EH): the agent's willingness to recognize, act on, and communicate uncertainty during task execution. We operationalize EH through three trajectory-level behavioral dimensions: Identify, Solve, and Escalate (ISE). Through knowledge conflict, situations where the backbone language model's parametric knowledge contradicts the evidence it encounters, or where two contextual sources disagree, we evaluate two conflict settings: (1) controlled conflict and (2) naturally occurring conflict during multi-step agentic execution, each paired with matched no-conflict controls. Evaluating four agents, we find that higher task accuracy does not necessarily correspond to greater epistemic humility: some high-accuracy configurations recognize conflicts during execution but do not communicate unresolved uncertainty in their incorrect final answers. Trajectory-level analysis further reveals that agents frequently detect conflicts in early steps of execution but fail to maintain or resolve them in later steps. Finally, we show that model-level interventions can improve EH, but often at the cost of task accuracy, suggesting that epistemic humility emerges from the interaction among the backbone model, agent harness, and evaluation environment.

Thu 8 OctArtificial IntelligenceComputation and Language
The gist
This paper looks at how AI agents handle situations when what they 'know' conflicts with new evidence they find. The authors check if agents change their answers, admit they’re unsure, or stubbornly stick to wrong conclusions. They find that even when agents get answers right more often, they don’t always admit uncertainty or explain their doubts. Also, agents might notice conflicts early on but fail to resolve or communicate them properly later. Adjustments to the underlying models can help agents be more humble but sometimes make them less accurate.
Open → 2610.12360v1

Communication topology improves diagnosis of multi-agent system failures

Know the Shape, Find the Fault: Topology-Conditioned Diagnosis of Multi-Agent LLM Failures

Abstract: Multi-agent LLM systems coordinate task execution through exchanges of information among agents. When coordination breaks down, similar symptoms in execution traces can reflect different problems in how information is passed, used, or verified. Communication topology captures how agents exchange information and provides structural cues for distinguishing coordination failure modes. Using these cues for diagnosis requires establishing how topology relates to failure patterns and recovering the relevant structure from execution traces that lack explicit topology labels. We analyze the relationship between communication topology and failure patterns and introduce MAScope, a two-stage framework for topology-conditioned diagnosis. Its Trace Structural Extractor TSE recovers communication topology from heterogeneous execution traces by grounding an interaction graph in message evidence. The Topology-Conditioned Judge TC-Judge then classifies failures using the trace, predicted topology, an empirical failure prior estimated from separate labeled traces, and a short description of topology-specific failure patterns. Under a fixed orchestration structure, the recovered topology can be reused across executions. Experimental results show a statistically significant association between communication topology and failure type, with $χ^2 = 409.9$ and $p = 1.2 \times 10^{-70}$. On the \num{851} MAST-clean traces, ground-truth topology context raises gpt-mini's Macro-F1 from $0.173$ to $0.350$. With predicted topology, the pipeline achieves $0.346$, approaching the trace-only gpt-5.4 baseline of $0.372$. For \num{1000} traces under a fixed orchestration structure, the projected pipeline cost, including one topology extraction, is approximately $6\%$ of repeated gpt-5.4 diagnosis cost. These results show that topology-conditioned context improves failure diagnosis and supports lower-cost deployment.

Wed 7 OctMultiagent SystemsArtificial Intelligence
The gist
When multiple AI agents work together, they share information to complete tasks, but sometimes their coordination fails. Different problems can look similar, so the authors studied how the pattern of communication between agents helps identify what exactly went wrong. They built a system called MAScope that figures out how agents interact from logs and uses this to better diagnose failures. Their tests show that knowing the communication structure makes diagnosis more accurate and efficient.
Open → 2610.10126v1

Confidence estimates struggle to keep up with changing AI knowledge

Evaluating Persistent Calibration under Evolving Model Knowledge

Abstract: As AI systems move from static repositories to agents that are capable of continual adaptation and learning, maintaining their trustworthiness means equipping the models backing them with the ability to produce confidence estimates that dynamically reflect their changing skills and knowledge. We introduce the problem of persistent calibration, which requires a confidence estimator to faithfully reflect the knowledge contained in a model as that knowledge changes, without recurring supervision. We operationalize this by examining persistent calibration across checkpoints of open models, asking whether confidence estimators trained on earlier checkpoints can generalize to later ones. Specifically, we aim to shed light on whether confidence is dependent on knowledge, a question with implications for the reliability of confidence estimates. To measure this relationship, we define and evaluate calibration on knowledge contrast sets: subsets containing questions that one checkpoint answers correctly and another checkpoint answers incorrectly, reflecting a change in knowledge. We show that both inference-time and fine-tuning methods fall short on contrast-set calibration compared to oracle methods trained on future checkpoints, even for methods that are well-calibrated on the full dataset. We provide evidence for the hypothesis that persistent calibration is challenging because there is a vast space of possible confidence functions that are well-calibrated on a given checkpoint, out of which only some rely on meta-knowledge features that would generalize to other checkpoints. Towards improving contrast-set calibration, we show that multi-checkpoint training helps, suggesting an avenue for identifying confidence features that remain robust across changing knowledge.

Wed 30 SeptMachine LearningArtificial IntelligenceComputation and Language
The gist
When AI systems learn and change over time, their confidence about answers should also change correctly to match what they know. The authors study whether confidence measures trained at one point still work well as the AI learns more or forgets things later. They find that confidence scores often fail to reflect these knowledge changes properly and perform worse on hard test sets designed to catch this problem. Training confidence estimators on multiple versions of the AI model can help improve how well confidence tracks changing knowledge.
Open → 2609.38797v1

Multi-agent systems can fail inside yet still give correct answers

Where Do Multi-Agent Systems Fail? Evidence-Grounded Diagnosis of Collective Mechanisms

Abstract: When a multi-agent system answers correctly, it is tempting to conclude that its agents shared, checked, and used information as intended. Yet a system can break one of its collective mechanisms, the rules that govern how agents route, admit, store, and act on shared information, and still return the right answer, while a wrong answer rarely reveals which mechanism failed. We ask what evidence from an execution is sufficient to conclude that a particular mechanism was violated. Our answer is a diagnostic contract, which separates what counts as a violation from which execution records can establish one, and concludes that a violation is supported, ruled out, or unknown; removing records can make this conclusion unknown but never reverse it. We test contracts for four mechanisms by replaying executions from the step where a mechanism acts, once unchanged, once with the mechanism broken, and once with it restored. Broken mechanisms often left the answer correct. An LLM diagnoser detected many more violations from internal records than from public outputs, yet with identical records a generic prompt often claimed certainty the records did not support, which prompts stating the contracts largely avoided. The contracts also applied, in narrow form, to mechanisms in independently developed systems, but a diagnostic behavior that was nearly perfect on our benchmark degraded on an independently developed workflow. A correct outcome is therefore no substitute for records of how collective mechanisms operated, and agreement on one benchmark does not show that a diagnoser transfers to another system.

Wed 30 SeptMultiagent Systems
The gist
When a group of computer agents work together to solve problems, they can sometimes break the rules about sharing and using information but still get the right answer. The authors studied how to tell if one of these rules was broken by looking at the system’s records, not just the final answer. They developed a method called diagnostic contracts to check whether evidence supports a violation of these rules. Their results show that just seeing a correct answer is not enough to know if the agents worked as they should, and tests on different systems reveal that what works for one doesn’t always work for another.
Open → 2609.38761v1

Tool builds causal graphs to diagnose agent failures effectively

From Anomalies to Failures: Constructing Causal Error Graphs for Agentic Trace Diagnosis

Abstract: LLM-driven agents are increasingly deployed in complex applications, where long agentic traces make failures difficult to diagnose. Existing trace diagnosis methods often conflate anomalies, errors, and failures, making diagnostic targets ambiguous; they also lack structured modeling of how causally relevant errors propagate and amplify into final task failures, resulting in unreliable failure attribution. To address these problems, we propose CEG-Agent, a tool-augmented agentic framework for causal diagnosis of agentic traces. Specifically, CEG-Agent introduces an explicit taxonomy of anomalies, errors, and failures, and constructs Causal Error Graphs (CEGs), a unified typed representation that links execution events, diagnostic nodes, and failure outcomes through causal relations. To evaluate causal trace diagnosis, we further construct CEG-Bench, a fully agent-annotated benchmark with high-confidence, consensus-derived CEG annotations obtained through an Adversarial Agentic Adjudication Protocol (AAAP). We validate the resulting annotations against an expert-curated human gold set, which shows close agreement with the automatic annotations. Experiments on CEG-Bench demonstrate that CEG-Agent achieves state-of-the-art performance under both semantically relaxed and structurally exact evaluation criteria. Our code is publicly available.

Sat 26 SeptArtificial Intelligence
The gist
When AI agents make mistakes in complex tasks, it can be hard to figure out why. The authors created a tool called CEG-Agent that separates different kinds of problems like anomalies, errors, and failures, and connects them in a clear cause-and-effect graph. They also made a benchmark called CEG-Bench to test how well this works, and found their tool matches expert human judgments closely. This helps people understand and fix why AI agents fail more reliably.
Open → 2609.32514v1

Certifying when machine learning predictions are reliable and detailed

Available Guardrails: Certifying Selective Prediction across ML Systems

Abstract: A selective predictor acts as a safety gate: it returns an output only when the prediction appears sufficiently trustworthy. Deployments increasingly require this reliability to be certified at a target precision for every reporting unit of interest, such as a tool, policy label, or patient subgroup. The main difficulty is often not whether a granted certificate is valid, but whether finite calibration data can produce one at all. As the gate becomes safer or more fine-grained, some units may receive too little evidence to certify. We make this notion of availability computable through classical exact-binomial inversion and formulate reporting-partition selection, under a fixed group order, as a dynamic program that exposes the trade-off among safety, granularity, and served traffic. The resulting frontier reveals a large population opportunity that finite-sample estimation nearly erases: a truth-informed planner gains $0.157$ mean coverage over support balancing, whereas a naive estimator recovers only $0.005$, making recovery from finite data the central challenge. Constructing candidate partitions on one planning split and selecting among them on another recovers part of this gap, improving mean coverage over support balancing by $0.060$, with the direction reproduced in $59$ of $60$ model effects across three intent-routing datasets and two architectures. A complementary validity-preserving lever, reallocating the familywise error budget across reporting units, recovers additional coverage both with population quantities and noisy estimates. The same frontier recurs, with predictor-specific ceilings, across LLM tool-calling, content moderation, lesion classification, and recommendation. Certified availability is therefore a plannable deployment resource that determines when a safety gate can be certified, at what granularity, and over how much traffic.

Fri 18 SeptMachine Learning
The gist
Machine learning systems often need to decide when to share predictions they can trust and when to hold back. The authors focus on figuring out when these "safety gates" can confidently say a prediction is safe, especially for different groups or categories within data. They developed a method to measure and plan this reliability, balancing how safe the predictions are with how many predictions they make and how specific those predictions are. Their results show that careful planning using their approach improves the amount of trustworthy predictions systems can safely make, validated across diverse applications like content moderation and medical diagnosis.
Open → 2609.22048v1

Efficient evaluation methods improve testing of evolving AI agents

Efficient Benchmarking in Production: A Study of an Evolving LLM Agent

Abstract: Production LLM agents are evaluated repeatedly as they evolve, but full agent benchmarks are costly to rerun. We study efficient recurring evaluation for a production analytics agent serving tens of thousands of monthly active users and report first-hand deployment experience. Using 574 historical runs of the production benchmark, split chronologically into calibration and held-out periods, we compare random sampling, historical caching, fixed representative subsets, and IRT-based adaptive testing. The results show that multidimensional 2PL adaptive testing achieves the best overall score fidelity: executing 200 questions, 38.5% of a full run, yields 1.03 pp of MAE. We nevertheless deployed difficulty-stratified fixed subsets because of their operational simplicity, and show they transfer without recalibration to five other agent families and remain stable across calibration windows as short as one day. Drawing on this deployment experience, we report practical recommendations for recurring production-agent evaluation.

Fri 18 SeptArtificial IntelligenceSoftware Engineering
The gist
Testing AI agents frequently is important but can be very expensive and time-consuming. The authors studied different ways to make repeated testing of a large AI agent more efficient using past test results. They found that a smart adaptive testing method worked best but chose a simpler fixed subset of questions for day-to-day use because it was easier to manage. This fixed method also worked well for other similar AI agents without needing changes. The paper shares advice from real-world experience on how to test AI agents in production regularly.
Open → 2609.21267v1

Large language models create diverse fault tolerant system code

DiverseFT: Diversifying Fault-Tolerant Systems using LLMs

Abstract: Fault-tolerant agreement protocols fail if replicas share a common flaw that simultaneously affects more replicas than the tolerable threshold. Therefore replicas should ideally fail independently, which can be achieved through diversification. However, in practice, often the same protocol implementation is shared by all replicas which is not surprising given that the provision of multiple diverse implementations is difficult and highly laborious. This poses a major risk, as a shared protocol implementation is a prime candidate for common bugs due to its complexity. With DiverseFT, we demonstrate how, given a reference implementation, Large Language Models (LLMs) can be utilised for the automated and scalable generation of code that compiles, passes tests, and crucially differs semantically/binary-wise, that can re- place code in the reference implementation, thereby significantly reducing diversification costs. We demonstrate the feasibility of diversification of replication protocol implementations using LLMs by diversifying three implementations: PBFT, HotStuff, and Raft, showing how up to 65% of the codebase can be diversified.

Wed 16 SeptDistributed, Parallel, and Cluster Computing
The gist
Fault-tolerant systems need many copies (replicas) of software that don't fail in the same way at the same time. Usually, all copies run identical software, which risks all failing together if there's a common bug. The authors show that large language models can automatically generate different versions of the same system code that still work correctly but differ enough to avoid shared bugs. They tested this on common protocols and managed to change up to 65% of the code, which could make systems safer and more reliable.
Open → 2609.18512v1

Continual search improves AI failure diagnosis in long tasks

Root-Cause Attribution Is a Search Problem: Continual Search for Long-Horizon Agent Failures

Abstract: The increasing deployment of AI agents in long-horizon tasks yields massive execution logs. Diagnosing failures within these records is crucial for reliability, as it transforms outcome-level signals into actionable interventions. The sheer scale of the data renders human review impractical, driving the need for automated root-cause attribution (RCA). However, automated RCA methods using LLMs suffer from low diagnostic accuracy, especially as execution traces grow larger. They struggle because relevant information is often sparse, distributed across distant actions, and disconnected from the visible failure, reducing root-cause attribution to a massive search problem. Existing RCA methods typically rely on one-shot LLM judgments to diagnose failures from execution traces. While effective for shorter trajectories, these judges tend to settle on a plausible diagnosis early, leaving critical evidence in longer traces unexamined. We introduce Continual Search, an iterative framework that nudges the judge, over successive turns, to keep searching for unresolved diagnostic evidence. We evaluate Continual Search across four existing RCA benchmarks. Recognizing the lack of massive execution traces in current benchmarks, we introduce MegaRCA-Mix to evaluate RCA at scale. MegaRCA-Mix provides a challenging testbed of 50 human-annotated failure trials spanning long-horizon, execution-heavy tasks. Across multiple benchmark suites and model families, Continual Search consistently improves attribution performance. On MegaRCA-Mix, for example, it improves GPT-5.5's F1 score by more than 40\%, from $0.349$ to $0.498$. More interestingly, within the same model family, lower-tier models can even surpass their higher-tier counterparts, demonstrating that effective search supersedes raw model scale.

Fri 11 SeptArtificial IntelligenceHuman-Computer InteractionMachine Learning
The gist
When AI systems work on long and complex tasks, they generate huge records of their actions, making it hard to figure out why they fail. The authors found that current methods using large language models (LLMs) have trouble pinpointing the true causes because the clues are hidden across many steps. They created a new approach called Continual Search that repeatedly prompts the AI to keep looking for important evidence instead of stopping too soon. This method significantly boosts the accuracy of diagnosing failures, even helping smaller models outperform larger ones when guided properly.
Open → 2609.13463v1