Development of an Autonomous Agent for Iterative Code Generation and Automated Debugging

Abstract

Recent progress in large language models (LLMs) has significantly improved automated code generation; however, most existing systems operate without execution awareness, often producing syntactically correct but semantically invalid or non-executable programs. The absence of runtime validation and structured debugging limits their reliability in practical software development environments. This paper presents an execution-guided multi-agent autonomous framework designed to enhance the robustness of AI-driven code synthesis. The proposed architecture incorporates specialized agents for task decomposition, implementation, and validation, coordinated through a centralized orchestration layer. Generated code is executed within a secure containerized sandbox, enabling controlled runtime analysis and structured feedback extraction. Execution traces, error logs, and exception data are utilized to drive an iterative self-refinement mechanism, allowing the system to autonomously detect and correct faults. The framework supports modular extensibility and domain-aware prompt conditioning to accommodate frontend, backend, full-stack, and low-level programming tasks. Experimental evaluation demonstrates improved execution success rates and reduced manual debugging effort compared to static generation approaches. The proposed method advances execution-aware AI systems toward reliable and self-healing software engineering automation.

Introduction

This paper proposes an execution-aware multi-agent autonomous framework for self-healing code generation that overcomes the limitations of traditional Large Language Model (LLM)-based coding systems. Existing AI code generation models primarily rely on static text generation without verifying whether the generated code compiles or executes correctly. As a result, developers must manually identify and fix compilation errors, runtime exceptions, dependency issues, and logical inconsistencies.

The proposed framework integrates planning, code generation, runtime validation, and iterative debugging into a unified closed-loop architecture. It employs three specialized agents—a Planner for task decomposition, a Developer for code synthesis, and a QA agent for validation—coordinated through a centralized orchestration layer. Generated code is executed inside a secure Docker-based sandbox, where execution logs, exceptions, and output states are collected as structured runtime feedback. This feedback is then used to iteratively regenerate and correct faulty code until successful execution or a predefined iteration limit is reached.

The study reviews existing approaches, including static code generation, reasoning-augmented models, execution-guided synthesis, and iterative refinement techniques, and identifies key limitations such as the lack of integrated runtime validation, insufficient use of execution feedback, and the separation of code generation from debugging.

The implementation uses a Python backend with FastAPI, API-based LLM integration, and Docker containers for secure execution. The methodology includes structured task decomposition, code synthesis, runtime feedback extraction, self-loop refinement, and convergence based on successful execution or maximum iteration limits.

Overall, the proposed system transforms AI-assisted programming from passive code generation into an active, self-correcting software development process, improving execution reliability, reducing manual debugging effort, and supporting diverse software development domains such as frontend, backend, full-stack, and low-level programming. Experimental evaluation demonstrates that execution-guided iterative refinement significantly improves program correctness and reliability compared to conventional static code generation methods.

Conclusion

This paper presented an execution-aware multi-agent autonomous framework for self-healing code generation. The architecture integrates structured task decomposition, code synthesis, sandboxed runtime validation, and iterative self-loop refinement within a coordinated agent-based pipeline. Unlike static generation systems that rely solely on probabilistic token prediction, the proposed framework incorporates execution feedback as a first-class component of the synthesis process. Experimental evaluation demonstrated significant improvements in execution success rate and debugging efficiency compared to a single-pass baseline model. The integration of runtime feedback into iterative regeneration enabled systematic correction of compilation failures, logical inconsistencies, and runtime exceptions. The bounded self-loop refinement strategy ensured convergence stability while maintaining computational efficiency. These results indicate that execution-aware validation substantially enhances reliability in autonomous code generation systems. The proposed architecture also supports heterogeneous programming domains, including backend services, frontend components, and low-level system applications, demonstrating its adaptability across diverse software engineering tasks. The modular orchestration design further enables extensibility and controlled integration of additional validation or analysis agents. Future work will focus on several directions. First, adaptive refinement policies could be introduced to dynamically adjust iteration thresholds based on task complexity. Second, integration of static analysis tools and formal verification techniques may further improve semantic correctness. Third, reinforcement learning-based feedback optimization could enhance convergence efficiency. Finally, large-scale benchmarking across standardized programming datasets would provide broader empirical validation of the framework’s generalization capability. By integrating reasoning, execution, and debugging into a unified closed-loop architecture, this work contributes toward more reliable and self-improving AI-driven software engineering systems

References

[1] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao, “ReAct: Synergizing Reasoning and Acting in Language Models,” in Proc. Int. Conf. Learning Representations (ICLR), 2023. [2] M. Chen, J. Tworek, H. Jun, et al., “Evaluating Large Language Models Trained on Code,” in Advances in Neural Information Processing Systems (NeurIPS), vol. 34, 2021. [3] P. Lewis, E. Perez, A. Piktus, et al., “Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks,” in Proc. Annual Meeting of the Association for Computational Linguistics (ACL), 2020. [4] A. Madaan, N. Tandon, P. Clark, et al., “Self-Refine: Iterative Refinement with Self-Feedback,” in Advances in Neural Information Processing Systems (NeurIPS), 2023. [5] X. Chen, C. Liu, and D. Song, “Execution-Guided Neural Program Synthesis,” in Proc. Int. Conf. Machine Learning (ICML), 2019. [6] T. Schick, J. Dwivedi-Yu, R. Dessì, et al., “Toolformer: Language Models Can Teach Themselves to Use Tools,” in Advances in Neural Information Processing Systems (NeurIPS), 2023. [7] J. Austin, A. Odena, M. Nye, et al., “Program Synthesis with Large Language Models,” in Advances in Neural Information Processing Systems (NeurIPS), 2021. [8] N. Jiang, T. Wang, J. Liang, and Y. Zhang, “Large Language Models Are Few-Shot Learners,” in Advances in Neural Information Processing Systems (NeurIPS), vol. 33, 2020. [9] J. Wei, X. Wang, D. Schuurmans, et al., “Chain-of-Thought Prompting Elicits Reasoning in Large Language Models,” in Advances in Neural Information Processing Systems (NeurIPS), 2022. [10] K. Narasimhan, T. Kulkarni, and R. Barzilay, “Learning to Execute,” in Proc. Int. Conf. Machine Learning (ICML), 2016.

Copyright

Copyright © 2026 Mrs. Dhulipalla Vijay Sree, Upputhalla Gayathri, Yeruva Puja, Tottempudi Mounika, Vakkalagadda Poojitha. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.