mlsanityData to 14 Oct 2026

Evaluating Agentic Code Repair Capabilities in Distributed Systems

arXiv 2608.14863 ↗First posted 14 Aug 2026cs.SE cs.AI cs.DCcited by 0

On the map: LLM agents and tool use → Software engineering coding agents

Abstract (arXiv)

LLM-based coding agents have advanced rapidly on single-process SWE tasks, with frontier models now clustering in the high-70s on SWE-bench Verified. Distributed-system debugging, however, remains an under-explored regime: bugs span processes, nodes, and protocol interactions, with root causes rarely recoverable from source alone and brute-force exploration intractable across non-deterministic interleavings. This leaves two gaps in LLM and agent evaluation: no code-repair benchmark targets distributed-system bugs, and no controlled study isolates how much externally provided debugging context changes agent success on them. We introduce DDBench, a code-repair benchmark of 60 historical bugs mined from 13 open-source distributed systems, partitioned into three difficulty tiers. DDBench evaluates every case under two matched conditions: a symptom-only condition where the agent receives only the bug symptom and repository, and a context-augmented condition where it additionally receives a bounded debugging context (logs, traces, runtime state, and targeted code-investigation notes), isolating the effect of debugging context from model capability. The evaluation of ten LLMs on DDBench reveals several findings. First, distributed debugging exercises a reasoning dimension that single-process benchmarks do not surface: models' pass rates span 61 pp, and pairwise bootstrap separates 9 of 15 top-tier model pairs at p < 0.05 on DDBench's hardest case-set. Second, bounded debugging context lifts aggregate pass rate by +18.1 pp, and the lift is asymmetric: weaker models gain pass rate, while stronger models gain efficiency. Third, debugging context requires careful curation, as even faithful debugging context can sometimes mislead LLMs.

Key facts. No citing papers in the map yet (data through 14 Oct 2026). Placed in Software engineering coding agents, one of 16 directions in LLM agents and tool use. Builds on 31 of its 42 references that are in the map. First posted on arXiv 14 Aug 2026.

Builds on

31 of 42 references.

Closest ancestors · 15

Same direction, newest first

  1. 2026CodeScout: Contextual Problem Statement Enhancement for Software Agents5 Mar
  2. 2026Cloud-OpsBench: A Reproducible Benchmark for Agentic Root Cause Analysis in Cloud Systems28 Feb
  3. 2026SWE-MiniSandbox: Container-Free Reinforcement Learning for Building Software Engineering Agents11 Feb
  4. 2026SWE-World: Building Software Engineering Agents in Docker-Free Environments3 Feb
  5. 2025SWE-EVO: Benchmarking Coding Agents in Long-Horizon Software Evolution Scenarios20 Dec
  6. 2025Live-SWE-agent: Can Software Engineering Agents Self-Evolve on the Fly?17 Nov
  7. 2025SWE-Effi: Re-Evaluating Software AI Agent System Effectiveness Under Resource Constraints11 Sep
  8. 2025SWE-rebench: An Automated Pipeline for Task Collection and Decontaminated Evaluation of Software Engineering Agents26 May
  9. 2025SWE-smith: Scaling Data for Software Engineering Agents30 Apr
  10. 2025AIOpsLab: A Holistic Framework to Evaluate AI Agents for Enabling Autonomous Clouds12 Jan
  11. 2024From LLMs to LLM-based Agents for Software Engineering: A Survey of Current, Challenges and Future5 Aug
  12. 2024OpenHands: An Open Platform for AI Software Developers as Generalist Agents23 Jul
3 more
  1. 2024Agentless: Demystifying LLM-based Software Engineering Agents1 Jul
  2. 2024SWT-Bench: Testing and Validating Real-World Bug-Fixes with Code Agents18 Jun
  3. 2024SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering6 May

Other references · 16

  1. 2023SWE-bench: Can Language Models Resolve Real-World GitHub Issues?cited by 3,373
  2. 2023Teaching Large Language Models to Self-Debugcited by 988
  3. 2026Terminal-Bench: Benchmarking Agents on Hard, Realistic Tasks in Command Line Interfacescited by 585
  4. 2024BigCodeBench: Benchmarking Code Generation with Diverse Function Calls and Complex Instructionscited by 546
  5. 2025SWE-Bench Pro: Can AI Agents Solve Long-Horizon Software Engineering Tasks?cited by 279
  6. 2025SWE-RL: Advancing LLM Reasoning via Reinforcement Learning on Open Software Evolutioncited by 263
  7. 2025Multi-SWE-bench: A Multilingual Benchmark for Issue Resolvingcited by 171
  8. 2024Debug like a Human: A Large Language Model Debugger via Verifying Runtime Execution Step-by-stepcited by 127
  9. 2024CodeR: Issue Resolving with Multi-Agent and Task Graphscited by 91
  10. 2025SWE-Fixer: Training Open-Source LLMs for Effective and Efficient GitHub Issue Resolutioncited by 90
  11. 2024DebugBench: Evaluating Debugging Capability of Large Language Modelscited by 76
  12. 2020Loghub: A Large Collection of System Log Datasets for AI-driven Log Analyticscited by 70
4 more
  1. 2023Recommending Root-Cause and Mitigation Steps for Cloud Incidents using Large Language Modelscited by 38
  2. 2025Traceback of Poisoning Attacks to Retrieval-Augmented Generationcited by 28
  3. 2023A Large-Scale Evaluation for Log Parsing Techniques: How Far Are We?cited by 26
  4. 2023OpsEval: A Comprehensive IT Operations Benchmark Suite for Large Language Modelscited by 5

Built on by

Not cited yet.

Similar, not cited

Close in wording, no citation either way

  1. 2026Repair or Resample? Rethinking Failure Debugging in LLM Multi-Agent Systems
  2. 2024UniDebugger: Hierarchical Multi-Agent Framework for Unified Software Debugging
  3. 2026AgentDebugX: An Open-Source Toolkit for Failure Observability, Attribution, and Recovery in LLM Agents
  4. 2025InspectCoder: Dynamic Analysis-Enabled Self Repair through interactive LLM-Debugger Collaboration
  5. 2026To Run or Not to Run: Analyzing the Cost-Effectiveness of Code Execution in LLM-Based Program Repair
  6. 2024An Empirical Study on LLM-based Agents for Automated Bug Fixing
  7. 2026ProcCtrlBench: Evaluating Process-Level Defects and Control Preservation in LLM Coding Agents
  8. 2026SelfHeal: Empirical Fix Pattern Analysis and Bug Repair in LLM Agents