- DevOps AI tools at a glance: incidents, Kubernetes and infrastructure
- Ten AI tools for SRE and platform teams
- Incident tools have rebranded as AI SREs
- Which part of the loop to automate first
- Guardrails before an agent touches production
- An assistant inside your monitoring, or an AI SRE outside it
- Replay an incident you've already solved
- My plain advice on adding AI to DevOps
- Frequently asked questions
AI tools for DevOps now investigate incidents, explain root causes, right-size Kubernetes and draft infrastructure changes, often as agents that can act and not just suggest. The first decision is which part of the loop to hand over: alert investigation, incident response or infrastructure change. Ten tools follow in no particular order.
Coding assistants get the headlines, but a lot of DevOps time goes after the code is written: chasing alerts at 3am, working out which change broke production, and keeping cloud infrastructure in line. That's the part of the loop this list covers.
The ten tools below are listed alphabetically and in no particular order, and every description comes from each vendor's own website, read as of Oct 2026. If you're choosing the monitoring layer these tools read from, my roundup of observability tools covers that first.
DevOps AI tools at a glance: incidents, Kubernetes and infrastructure
I checked the free plan column on each vendor's own website, as of Oct 2026. Yes means the page names a free plan, a free version or an open source edition. Trial only means the page names a time-limited free trial. Not stated means the page I read named neither, so check the vendor's own site before you sign up.
| Tool | Type | Good for | Free plan |
|---|---|---|---|
| Cast AI | Kubernetes automation | Right-sizing Kubernetes workloads and GPUs | Trial only |
| Datadog Bits AI | SRE agent inside Datadog | Teams already on Datadog | Trial only |
| Dynatrace | AI for operations and observability | Root-cause analysis at scale | Not stated |
| GitLab Duo Agent Platform | AI agents inside GitLab | Teams planning, coding and securing in GitLab | Trial only |
| incident.io | AI incident platform | Incident response with an AI agent alongside | Not stated |
| Komodor | Agentic operations for Kubernetes | Troubleshooting Kubernetes in production | Not stated |
| New Relic AI | Observability assistant | Teams on New Relic | Not stated |
| Pulumi Neo | AI infrastructure agent | Infrastructure as code teams | Not stated |
| ResolveAI | AI SRE platform | Autonomous incident investigation | Not stated |
| Rootly | AI-native incident management | On-call and incident response | Not stated |
Ten AI tools for SRE and platform teams
Cast AI
Best for: Kubernetes teams who want workloads right-sized automatically, agents opening pull requests for infra fixes and plain-English questions about pods.
Datadog Bits AI
Best for: Datadog customers who want an always-on SRE agent to work through complex troubleshooting and late-night alerts.
Dynatrace
Best for: Large estates that want deterministic root-cause answers feeding agentic automation for prevention, remediation and optimisation.
GitLab Duo Agent Platform
Best for: GitLab teams who want agents for planning, coding, security analysis and analytics, each using GitLab context, managed from one catalogue.
incident.io
Best for: Responders who want people and an AI agent working together from the moment an alert fires all the way through to resolution.
Komodor
Best for: Kubernetes operators who want pre-built agentic workflows that turn scattered alerts into one war room and fix root causes in code.
New Relic AI
Best for: New Relic users who want to ask about telemetry in everyday language, generate system health reports and find gaps in alert coverage.
Pulumi Neo
Best for: Platform teams who want an agent to provision, govern and optimise cloud infrastructure, with enterprise controls built in.
ResolveAI
Best for: On-call engineers who want an AI SRE that connects the dots across on-call questions and incidents, using its own domain models.
Rootly
Best for: Teams wanting on-call, incident response, an AI SRE, retrospectives and a status page inside one incident platform.
Incident tools have rebranded as AI SREs
When I read the vendor pages side by side, the incident category had a new name. ResolveAI's page is titled AI SRE platform, incident.io calls itself an AI software reliability platform, Rootly an AI-native incident management platform and Komodor the agentic operations platform for production. Even infrastructure tools are moving: the old env0 address now opens env zero, billed as the autonomous cloud control plane for the AI era.
Behind the labels, the shift is from tools that summarise an incident to agents that investigate it and propose, or make, the fix. That's powerful at 3am, and it's exactly why guardrails matter. If your work leans toward building software rather than running it, I've compared AI tools for engineers.
Which part of the loop to automate first
- Investigation. AI inside your observability platform reads telemetry and suggests a root cause. Easiest to start with, because it reads and doesn't change anything.
- Incident response. An incident platform with an AI SRE pulls responders together, gathers context and drafts the timeline and retrospective.
- Kubernetes operations. Agents right-size workloads, troubleshoot pods and open pull requests for fixes.
- Infrastructure change. Agents provision and govern cloud resources from code, alongside the coding agents your team already uses.
Engineers who've been on call and learned from it can pitch a DevOps article through my DevOps contributor guidelines.
Guardrails before an agent touches production
- Start read-only. One Kubernetes tool here suggests you begin by letting it only look at your cluster, then turn automation on when you're ready.
- Require approval for changes. Pull requests and change reviews should still pass a human, at least at first.
- Scope the credentials. Give each agent the narrowest access it needs, per environment.
- Keep an audit trail. Every action an agent takes should be logged and easy to roll back.
- Measure it. Track time to resolve and repeat incidents before and after, so you know it's helping.
Most of these agents change infrastructure through code, so it pays to get that layer right. My guide to infrastructure as code tools covers the options.
Do you make AI tools for DevOps teams? Tool makers can ask to be considered for a featured place on this list.
Want AI doing the heavy lifting in your marketing?
I build the systems that handle the boring 80 percent, so you get your week back. Done properly, with the human kept in.
An assistant inside your monitoring, or an AI SRE outside it
You'll most likely meet an AI SRE for the first time halfway through an incident, typing a question into whichever window is already open, rather than in a calm evaluation. That habit decides more than any feature list, because the agent you reach for under pressure is the one sitting in the tool you already stare at. So the first fork is about where the agent lives.
A native assistant lives inside your observability platform; Datadog Bits AI and New Relic AI are this kind. Its strength is depth. It reads the metrics, logs and traces that platform already holds, using the service names and dashboards your engineers know, and there's nothing new to connect. Its limit is the edge of that platform. If the clue sits in a deploy log, a feature flag change or a ticket in another system, a native assistant may never see it, and it will reason confidently from what it can see.
An independent AI SRE sits outside any one monitoring tool and can connect to several sources, such as monitoring, source control, deploy pipelines and team chat. It suits teams whose telemetry is split, perhaps after an acquisition or because each team picked its own stack. The price of that breadth is set-up and trust. Every connection is another credential to scope, and the quality of its answers depends on how much of your estate you've wired in. Half-connected, it can be worse than a native assistant, because it looks as if it sees everything.
If most of your signals already land in one platform, I'd start with the assistant inside it and judge it for a few weeks before buying anything new. If your engineers routinely hop between several tools to piece together one incident, the independent kind earns its set-up, because joining clues across tools is the part a human finds slowest.
Replay an incident you've already solved
The trial that tells you most uses an incident whose ending you already know. Suppose a recent outage started when a config change raised connection pool limits on one service, which then exhausted the database's connections, while the first alerts fired on a different service further downstream. Your team took a while to trace it back. That makes it a strong test case, precisely because the obvious alert points the wrong way.
Give the agent the access your on-call engineer had at the start, read-only, plus the first alert as it arrived, and nothing from the retrospective. If the tool indexes past retrospectives, take that one out, or it will find the answer rather than work it out. Then watch. Does it ask for deploy history, or stay inside the alerting service's metrics? Does it name the config change, name a plausible but wrong cause, or say it can't tell? Does each claim point to a log line, graph or change you can open and check?
An agent that blames the downstream service and stops is doing what a tired engineer does. One that says it can't see deploy history is more useful than one that guesses, because it tells you what to connect next. The riskiest outcome is the right answer with no evidence trail, since in a live incident you'd have no way to tell its good days from its bad ones. Run the same replay on each tool on your shortlist, with identical access, and the comparison largely does itself.
Then put one question to every vendor: when your agent isn't sure of a root cause, what exactly does it show the engineer?
My plain advice on adding AI to DevOps
Start where AI reads rather than writes. Turn on AI investigation in the observability platform you already run, and see whether its root-cause suggestions match what your engineers find. Once you trust it, move to an AI SRE for incident response, and only then let agents change infrastructure, behind pull requests and approvals. Don't hand an agent production access on day one. Many teams start with the platform they run today, and Datadog versus Dynatrace is a useful comparison.
And if you're running AI features in your own product, monitoring them is a separate job. My roundup of LLM observability tools covers that side.
Want your tool on this list? Featured spots and reviews here are paid partnerships. Here's how to partner with me.
Frequently asked questions
What is an AI SRE?
It's an AI agent that works alongside site reliability engineers, investigating alerts, gathering context during incidents and suggesting or making fixes.
How is AI used in DevOps?
Teams use it to investigate alerts, find root causes, coordinate incident response, right-size Kubernetes workloads and draft or govern infrastructure changes.
Is it safe to let AI change production?
Only with guardrails: read-only access first, approvals for changes, scoped credentials and a full audit trail. Many teams keep humans approving every change.
Are there free AI tools for DevOps?
None of the pages here named a free plan when I read them. Several name a free trial, shown in the free plan column, so check each vendor's own site.
Do AI DevOps tools replace on-call engineers?
No. The vendors pitch them as working with people, taking the first investigation so engineers can decide and fix faster.
What are the alternatives to Datadog Bits AI?
There are two kinds. Other observability platforms have their own assistants, which only make sense if you'd move your monitoring too. Otherwise look at an incident platform that includes an AI SRE, or a standalone AI SRE, which is built to connect to the monitoring you already run rather than replace it.