Software developers spend roughly half their time not writing code but understanding it — reading documentation, tracing dependencies, and figuring out why something broke. This reality has made automated issue resolution one of the most consequential applications of AI agents. The field has progressed rapidly from code completion to systems that can autonomously localize bugs across complex repositories, plan multi-file fixes, and validate their own patches. Three recent systems illustrate how different this new generation of coding agents looks from the autocomplete tools of just two years ago.
The Limited Observation Scope Problem
Current agent-based approaches to issue resolution share a fundamental weakness: they rely on individual agents independently exploring a codebase and proposing fixes. Li, Shi, Lin et al. (2025) identify this as the "limited observation scope" problem. When multiple code locations appear relevant to an issue description, a single agent cannot systematically evaluate the architectural trade-offs between competing modification strategies. It gets stuck in local solutions, missing issue patterns that span across different parts of the codebase.
SWE-Debate addresses this through a three-stage pipeline. First, it constructs a static dependency graph of the codebase and generates multiple fault propagation traces — structured chains of code entities (classes, methods, functions) that trace how defects might propagate through dependency relationships. These traces serve as competing hypotheses about where the root cause lies.
Then comes the distinctive element: a structured three-round competitive debate among specialized agents. Each agent embodies a different reasoning perspective along a fault propagation trace, proposing and defending candidate modification plans while critiquing alternatives. A discriminator synthesizes the most promising insights into a consolidated fix plan, which is then executed through a Monte Carlo Tree Search framework for patch generation.
On the SWE-Bench-Verified dataset, this approach achieved a 6.7% improvement in issue resolution rate and a 5.1% improvement in fault localization accuracy over state-of-the-art open-source baselines. Ablation studies confirmed that the fault propagation traces — the structural innovation that enables diverse reasoning perspectives — provided the largest contribution to overall performance.
The Generalist Approach
Where SWE-Debate specializes in issue resolution through debate, HyperAgent (Phan, Nguyen, Nguyen, and Bui, 2024) pursues breadth. It is designed as a generalist multi-agent system that handles the full spectrum of software engineering tasks — from GitHub issue resolution to repository-level code generation to fault localization and program repair — across multiple programming languages.
HyperAgent's architecture mirrors how human developers actually work. Four specialized agents collaborate through an asynchronous message queue: a Planner that serves as the central decision-making unit, a Navigator that explores the repository to locate relevant code, a Code Editor that implements changes, and an Executor that runs tests to verify correctness. The Planner centralizes complex reasoning while delegating computationally intensive but conceptually simpler tasks to child agents, optimizing inference costs.
The system achieves state-of-the-art results across diverse benchmarks including SWE-Bench for Python issue resolution, RepoExec for repository-level code generation, and Defects4J for Java fault localization and repair. The authors note that HyperAgent is the first system designed to work across diverse software engineering tasks in multiple programming languages without requiring task-specific adaptations.
Learning from Human Experience
MemGovern (Wang, Cheng, Zhang et al., 2026) introduces a fundamentally different perspective: rather than improving the agent's reasoning about code, it improves its access to collective human debugging knowledge. The authors observe that current code agents operate in a "closed world," attempting to fix bugs from scratch while ignoring the vast repository of resolved issues, pull requests, and patches available on platforms like GitHub.
The challenge is that this human experience is noisy, unstructured, and fragmented — raw GitHub discussions interleave failure symptoms with social exchanges and repository-specific jargon. MemGovern addresses this through experience governance, a systematic pipeline that transforms chaotic raw data into structured "experience cards." Each card has two layers: an Index Layer containing a normalized problem summary and diagnostic signals for retrieval, and a Resolution Layer capturing root cause analysis, fix strategies, and patch details.
By producing 135,000 governed experience cards and equipping agents with an agentic experience search strategy — where agents iteratively search and browse experience records much as human engineers consult Stack Overflow or prior pull requests — MemGovern improves resolution rates on SWE-Bench Verified by 4.65% on average across multiple LLM backbones, functioning as a plug-in module that can enhance any existing code agent.
Open Questions
The rapid evolution of coding agents raises several unresolved tensions. SWE-Debate shows that structured disagreement between agents improves fault localization, but at what computational cost? HyperAgent demonstrates generalist capability, but can a single architecture truly handle the diversity of real-world software engineering? And MemGovern's approach of learning from human experience assumes that historical solutions remain relevant — an assumption that may weaken as codebases and frameworks evolve.
Perhaps the most interesting convergence is that all three systems, in different ways, are moving beyond the paradigm of a single agent reading code and proposing a fix. The future of automated software engineering appears to lie in structured collaboration — whether between multiple agents debating competing hypotheses, between specialized agents mimicking human team workflows, or between AI agents and the accumulated wisdom of human developers.
References
Li, H., Shi, Y., Lin, S., Gu, X., Lian, H., Wang, X., Jia, Y., Huang, T., & Wang, Q. (2025). SWE-Debate: Competitive multi-agent debate for software issue resolution. arXiv preprint, arXiv:2507.23348.
Phan, H. N., Nguyen, T. N., Nguyen, P. X., & Bui, N. D. Q. (2024). HyperAgent: Generalist software engineering agents to solve coding tasks at scale. arXiv preprint, arXiv:2409.16299.
Wang, Q., Cheng, Z., Zhang, S., Liu, F., Xu, R., Lian, H., Wang, K., Yu, X., Yin, J., Hu, S., Hu, Y., Zhang, S., Liu, Y., Chen, R., & Wang, H. (2026). MemGovern: Enhancing code agents through learning from governed human experiences. arXiv preprint, arXiv:2601.06789.