Towards Adaptive Software Agents for Debugging

2025-04-25

AI Summary

Fixed-agent multi-LLM debugging frameworks incur escalating computational costs and attention fragmentation as the number of agents remains static regardless of defect complexity. Method: This paper proposes a dynamic adaptive multi-agent debugging framework that adjusts agent count and roles in real time based on code defect complexity. It integrates a complexity-aware module, dynamic task decomposition, and LLM coordination mechanisms, enabling the first task-driven, on-the-fly generation of agent roles—departing from rigid, predefined role schemas. Contribution/Results: Experiments on code repair tasks demonstrate an 11% accuracy improvement over single-prompt baselines: simple syntactic errors are resolved by a single agent, while complex defects automatically trigger coordinated multi-agent execution. This adaptivity significantly reduces redundant computation and inter-agent communication overhead.

Technology Category

Multiagent Systems: TeamworkMachine Learning: Large Multimodal Models (LMMs)Cognitive Modeling & Cognitive Systems: Agent Architectures

Application Category

Search and Retrieval-Augmented AI: Agentic searchEconomics, Online Markets and Human Computation: Cost models of using LLMs in production systemsSemantics and Knowledge: Data modeling to support human-machine intelligence, including LLMs agents, intelligent system behavior, explanations, and user-friendly interactions

Abstract

Using multiple agents was found to improve the debugging capabilities of Large Language Models. However, increasing the number of LLM-agents has several drawbacks such as increasing the running costs and rising the risk for the agents to lose focus. In this work, we propose an adaptive agentic design, where the number of agents and their roles are determined dynamically based on the characteristics of the task to be achieved. In this design, the agents roles are not predefined, but are generated after analyzing the problem to be solved. Our initial evaluation shows that, with the adaptive design, the number of agents that are generated depends on the complexity of the buggy code. In fact, for simple code with mere syntax issues, the problem was usually fixed using one agent only. However, for more complex problems, we noticed the creation of a higher number of agents. Regarding the effectiveness of the fix, we noticed an average improvement of 11% compared to the one-shot prompting. Given these promising results, we outline future research directions to improve our design for adaptive software agents that can autonomously plan and conduct their software goals.

Problem

• Dynamic agent allocation for efficient LLM-based debugging
• Reducing costs and focus loss in multi-agent debugging systems
• Adaptive agent roles based on code complexity analysis

Innovation

• Dynamic agent count based on task complexity
• Roles generated post problem analysis
• 11% average fix improvement over one-shot