A Closed-Loop Agentic AI Framework for Self -Configuring, Self-Healing, and Optimized CI/CD Automation

Abstract

Static continuous integration and continuous delivery pipelines remain difficult to adapt when repositories, dependencies, deployment targets, and operational conditions change. Manual configuration also slows failure diagnosis and prevents pipelines from learning from previous executions. This paper presents DevOps-Pilot, a closed-loop agentic AI framework for intelligent DevOps automation. The framework analyses repository context, detects languages, dependency files, build tools, test frameworks, Docker assets, and Kubernetes manifests, and then uses LLM-assisted planning to generate Jenkins-compatible pipeline definitions. Pipeline execution is monitored through a Flask dashboard and SQLite-backed history store, while anomaly detection and self-healing logic recommend recovery actions for installation, testing, and deployment failures. A reinforcement learning-inspired optimisation policy updates cache, parallel testing, retry, and timeout settings from observed rewards. The academic prototype was evaluated in simulation mode across four repositories and nine pipeline runs. Results show six successful and three failed runs, a success rate of 66.67%, an average execution time of 120.52 seconds, and an average reward of 3.2641. The findings indicate the feasibility of closed-loop CI/CD automation for adaptive software delivery.

Introduction

This paper presents DevOps-Pilot, a closed-loop agentic AI framework that automates and continuously improves CI/CD (Continuous Integration and Continuous Delivery) pipelines. Traditional CI/CD pipelines are often static, manually configured, and difficult to maintain across different programming languages and deployment environments. They also lack learning capabilities, making failure diagnosis and pipeline optimization dependent on human expertise.

The proposed framework addresses these limitations by treating CI/CD as a continuous decision-making process. It analyzes repository context, automatically generates Jenkins-compatible pipelines using LLM-assisted planning, executes and monitors pipeline stages, applies self-healing strategies when failures occur, records execution history, and optimizes future pipeline configurations using a reward-based learning approach.

Key Features

• Context-aware repository analysis to detect programming language, dependencies, build tools, testing frameworks, Docker, and Kubernetes support.
• Automatic pipeline generation using repository evidence rather than generic templates.
• Continuous monitoring of execution status, runtime, and failures.
• Self-healing mechanisms that recommend recovery actions such as reinstalling dependencies, rerunning tests, or rolling back deployments.
• Reinforcement learning-inspired optimization that adjusts cache usage, retry count, timeout values, and test parallelization based on previous execution results.
• A Flask-based prototype with a dashboard, REST APIs, SQLite database, and simulation mode for academic evaluation.

Framework Architecture

DevOps-Pilot consists of multiple cooperating agents:

1. Repository Input
2. Context Analysis
3. Pipeline Planning
4. Orchestration
5. Execution
6. Monitoring
7. Self-Healing
8. Execution History
9. Optimization

These modules exchange structured records, making the framework modular, explainable, and easy to evaluate.

Methodology

The system first extracts repository information such as programming language, dependency files, build tools, testing frameworks, and deployment environment. Based on this context, it generates an appropriate Jenkins pipeline. Pipeline execution is monitored, anomalies and failures are detected, recovery actions are applied, and execution outcomes are stored. A reward function evaluates performance by considering execution time, failures, and successful completion, enabling continuous policy improvement.

Implementation

The prototype was implemented using:

• Python Flask backend
• Bootstrap dashboard
• SQLite database
• Optional integration with Jenkins, Docker, and Kubernetes
• Simulation mode to evaluate pipeline behavior without requiring production infrastructure

The dashboard displays repository statistics, execution history, success rates, execution time, rewards, and optimization policies.

Results

The prototype was evaluated using 4 repositories and 9 simulated pipeline executions:

• 6 successful runs
• 3 failed runs
• 66.67% success rate
• Average execution time: 120.52 seconds
• Average reward: 3.2641

The optimization policy learned to enable caching, parallel testing, retries, and increased timeout values, resulting in improved execution performance. Failed executions were successfully used as learning signals, demonstrating that the framework continuously improves pipeline planning and recovery.

Conclusion

DevOps-Pilot demonstrates a closed-loop agentic AI frame-work for CI/CD automation. It integrates repository analysis, LLM-assisted planning, execution monitoring, self-healing, execution history, and optimisation. Prototype results show a 66.67% success rate and an average execution time of 120.52 seconds across nine simulated runs. Reward-based optimisa-tion enabled cache, parallel testing, retry count, and extended timeout. The framework therefore represents a practical step towards autonomous DevOps and intelligent software deliv-ery while remaining clear about the additional engineering re-quired for production deployment.

References

[1] Humble, J., Farley, D.: Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation. Addison-Wesley, Boston, USA, 2010. [2] Bass, L., Weber, I., Zhu, L.: DevOps: A Software Architect’s Perspective. Addison-Wesley, Boston, USA, 2015. [3] Jenkins Project: Jenkins User Documentation. Avail-able at: https://www.jenkins.io/doc/, ac-cessed 2026. [4] Docker Inc.: Docker Documentation. Available at: [5] https://docs.docker.com/, accessed 2026. [6] Kubernetes Authors: Kubernetes Documentation. Avail-able at: https://kubernetes.io/docs/, ac-cessed 2026. [7] Sutton, R.S., Barto, A.G.: Reinforcement Learning: An Introduction. MIT Press, Cambridge, USA, 2018. [8] Wooldridge, M.: An Introduction to MultiAgent Systems. Wiley, Chichester, UK, 2009. [9] Chen, M., Tworek, J., Jun, H., et al.: Evaluating Large Language Models Trained on Code. arXiv:2107.03374, 2021. [10] Fan, A., Gokkaya, B., Harman, M., et al.: Large Lan-guage Models for Software Engineering: Survey and Open Problems. arXiv:2310.03533, 2023. [11] Liu, J., Wang, K., Chen, Y., et al.: Large Language Model-Based Agents for Software Engineering: A Sur-vey. arXiv:2409.02977, 2024. [12] Zhang, L., Jia, T., Jia, M., et al.: A Survey of AIOps for Failure Management in the Era of Large Language Models. arXiv:2406.11213, 2024. [13] Zhang, L., Jia, T., Jia, M., et al.: A Survey of AIOps in the Era of Large Language Models. arXiv:2507.12472, 2025.

Copyright

Copyright © 2026 A. Hitesh Reddy, A. Jitendra. 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.