AI-powered automation platform for DevOps teams

About the project

Our client, a company building a DevOps platform, needed a smart tool that could continuously analyze Kubernetes clusters and detect issues early. The solution had to not only identify and resolve problems, but also predict potential failures before they happened. The main objective was to achieve a high issue detection rate while keeping false alerts to a minimum, ensuring stable, always-on cluster monitoring without requiring manual involvement.

Challenge

The initial system depended on predefined tests, which meant it could only catch issues that were already known and documented. As a result, any new, unexpected, or unusual problems went unnoticed unless someone had created a specific test for them in advance. To overcome this limitation, the client wanted to bring AI-driven automation into the platform — allowing the system to review all cluster resources, spot anomalies, and deliver clear, actionable insights to engineers without relying on predefined problem definitions.

Development process

A key part of the project was finding the right balance between cost and accuracy. We tested several Machine Learning models and compared both their performance and pricing. While GPT-based models delivered outstanding results with close to 99% precision, they were too expensive for real-time analysis at scale. After extensive evaluation, we selected Llama 3.1 (8B parameters) as the best cost-effective option, offering strong accuracy while keeping operational expenses under control.

Another major challenge was processing Kubernetes clusters efficiently. Since clusters can include thousands of different resources, analyzing them one by one would have been slow and costly. To improve performance, we built a system that could work synchronously while running multiple tasks in parallel. This allowed us to analyze large environments quickly without sacrificing reliability.

• Implemented a step-limited AI approach to ensure accurate issue detection without unnecessary processing.
• Developed an AI agent capable of running Kubernetes CLI commands, enabling real-time diagnostics and deeper resource inspection.
• Used LangChain and LangGraph to orchestrate workflows, visualize results, and produce structured AI-generated conclusions.

The platform was designed to handle different levels of resource complexity. High-complexity components such as Pods and Nodes required deeper analysis, while simpler resources like ConfigMaps, Services, Ingress, PVC, and CronJobs were processed using lightweight models to keep costs efficient.

To automate decision-making and control expenses, we introduced a dynamic model-switching mechanism. The system automatically selected the best model based on the complexity of the resource and the likelihood of an issue.

This setup removed the need for manual intervention and allowed the solution to run fully autonomously. We also enhanced performance through a multi-agent parallelization strategy: one agent handled resource discovery, another executed Kubernetes commands and diagnostics, and a third generated structured reports with clear explanations.

The solution was thoroughly tested using a Kubernetes test cluster provided by the client. Throughout the process, we fine-tuned the system based on core metrics such as detection accuracy, response validation, and processing speed. Our target was to reach 90% precision while maintaining an optimized cost — and we successfully achieved that goal.

Technologies

TypeScript

HTML 5

Sass

RxJS

Angular

NGRX

Highcharts

WebSockets

Ag-grid

Java

Spring Boot

Gradle

Apache Flink

Node.js

REST API

Swagger

PostgreSQL

Cassandra

Redis

Kafka

RabbitMQ

Docker

Kubernetes

Helm

Prometheus

Business value

By automating Kubernetes health assessments, this solution significantly reduced the amount of manual work engineers typically spend on routine checks. Instead of reacting only when failures occur, teams can now monitor cluster health continuously and proactively detect risks before they turn into service disruptions.

Whenever the system detects an issue, it provides:

• Detailed diagnostics with root cause analysis
• Clear, actionable remediation steps for engineers
• Transparent AI reasoning, so users can understand how each conclusion was reached

Beyond improving operational efficiency, the tool helps protect business continuity by preventing unexpected downtime. For platforms that depend on always-on availability, it works like an AI-powered DevOps engineer — automating health checks, strengthening Kubernetes stability, and supporting faster, smarter decision-making.