TL;DR
The best open source AI SRE tools in 2026 are K8sGPT for quick Kubernetes diagnostics, HolmesGPT (with Robusta) for multi-step incident investigation, and Keep for alert correlation. All ten below are Apache 2.0 or MIT licensed, and 3 are CNCF sandbox projects.
- 1.K8sGPT: Kubernetes diagnostics
- 2.HolmesGPT: Multi-step investigation
- 3.Robusta Open Source: Alert enrichment
- 4.kagent: Framework to build agents
- 5.Keep: Alert correlation
- 6.kubectl-ai: Natural language kubectl
- 7.Botkube: ChatOps with AI Doctor
- 8.kube-copilot: Multi-tool K8s AI
- 9.SigNoz: Observability with AI awareness
- 10.GeniA: Slack-based DevOps assistant
10
Open source tools compared
agents, frameworks, ChatOps, observability
3
CNCF sandbox projects
K8sGPT, HolmesGPT, kagent
6 + 4
Apache 2.0 and MIT licensed
every tool is permissively licensed
Nov 2026
Last checked
licenses and activity from GitHub
AI SRE is one of the fastest moving categories in operations tooling right now. Agents that read logs, correlate metrics, investigate incidents, and post draft root cause analysis to Slack are becoming the new layer that sits on top of your observability stack.
Most of the attention has gone to commercial tools, but there is a real open source ecosystem underneath. Teams that want to self-host, run inside their own perimeter, keep LLM costs under their own control, or just avoid another SaaS contract are building serious AI SRE capability with open source tools. This page is a landscape of the ten best open source AI SRE tools available in 2026.
What to look for in an open source AI SRE tool
Before the tools, the criteria. These are the things that separate a serious open source AI SRE project from a weekend GitHub repo.
Active maintenance
Look at commit frequency, release cadence, and how recently issues are being closed. AI SRE moves fast and dormant projects get left behind in months.
LLM provider flexibility
The strongest projects let you plug in OpenAI, Anthropic, local models through Ollama, or anything that speaks OpenAI-compatible API. Lock-in to one provider is a red flag.
Real production usage
Check if the project is used by companies, not just hobby deployments. CNCF sandbox or incubating status helps. Named production users help even more.
Clear investigation scope
Open source AI SRE tools work best when they focus on a specific layer (Kubernetes, alerts, specific services) rather than trying to do everything.
License
Apache 2.0 and MIT are the most permissive. AGPL can create compliance issues for commercial teams depending on how they use the tool.
The 10 best open source AI SRE tools in 2026
K8sGPT
Kubernetes diagnosticsThe most well-known open source AI SRE project in the Kubernetes world. K8sGPT is a CNCF sandbox project written in Go that scans Kubernetes clusters, detects issues, and uses an LLM to explain what is wrong in plain English.
What it does well
- Supports multiple LLM backends out of the box. OpenAI, Anthropic, Azure OpenAI, local models via Ollama, and more.
- Fast scans across the cluster with configurable analyzers for different Kubernetes resources.
- CNCF-backed, which gives it a credibility and governance layer most open source projects lack.
- CLI-first, so it fits naturally into existing kubectl workflows.
- Includes an anonymize flag that masks object names and labels before they reach the model.
Where it falls short
- Focused on detection and explanation, less on deep multi-step investigation.
- Limited integration with non-Kubernetes signals. If your incident needs you to correlate a pod issue with a recent Git deploy or an external database metric, K8sGPT does not do that natively.
Teams running production Kubernetes who want a low-friction first step into AI-assisted operations. Especially good if your incidents are mostly contained to the Kubernetes layer.
HolmesGPT
Multi-step investigationHolmesGPT is a purpose-built open source AI SRE agent, originally created by the team at Robusta and now a CNCF sandbox project in its own right. Where K8sGPT is diagnostic-assistant-shaped, HolmesGPT is investigation-agent-shaped. You give it an alert and it runs multi-step investigations across Kubernetes, Prometheus, Grafana, Loki, and other sources to figure out what is actually happening.
What it does well
- Multi-step investigation, not just single-shot diagnosis. The agent pulls in logs, checks events, examines pod state, and correlates signals to build a real root cause hypothesis.
- Read only by default, with an opt-in remediation toolset where each change waits for a human.
- Supports multiple LLM providers.
- Integrates with the broader Robusta ecosystem for alert enrichment and Slack posting.
Where it falls short
- Its roots and deepest integrations are in Kubernetes. The project now covers VMs, cloud providers and databases too, but check the toolsets for your stack before you rely on it outside Kubernetes.
- The full Slack and alert-enrichment experience comes from running it with Robusta Open Source, which adds setup if you are not already running Robusta.
- LLM costs can add up if you run it autonomously against every alert without tuning.
Teams who want an agentic investigation layer in open source, are already running Kubernetes, and are comfortable with Python-based tools that need some ops attention.
Robusta Open Source
Alert enrichmentRobusta is the broader Kubernetes observability and alerting platform that HolmesGPT plugs into. On its own, Robusta is not an AI SRE tool. It is an open source alert enrichment and Kubernetes event management platform. But combined with HolmesGPT, it becomes a full open source AI SRE stack.
What it does well
- Enriches raw Kubernetes alerts with context (pod logs, events, resource usage, related alerts).
- Automated remediation workflows for common Kubernetes issues.
- Slack-first by design, so alert routing and context delivery feel native to incident response.
- Strong plugin architecture for adding new enrichment and automation.
Where it falls short
- Not AI-native on its own. The AI SRE capability comes from pairing with HolmesGPT.
- Setup and tuning takes meaningful ops time, especially in multi-cluster environments.
Teams who want the full Robusta plus HolmesGPT stack as their open source AI SRE foundation.
kagent
Framework to build agentskagent is a CNCF sandbox project from Solo.io that provides a Kubernetes-native framework for building your own AI agents. Agents and tools are defined as Kubernetes resources, making the whole thing feel native if your team already lives in kubectl.
What it does well
- Agents and tools are declarative Kubernetes resources, which fits GitOps workflows cleanly.
- Tools can require approval before running, giving teams fine-grained control over what AI agents are allowed to do.
- Built for extensibility, so teams can roll their own investigation or remediation agents on top of the framework.
- CNCF-backed with active maintenance.
Where it falls short
- Framework, not a finished product. You still have to build the agent logic yourself.
- Best suited for teams that have the engineering bandwidth to invest in custom agent development.
Teams that want to build their own AI SRE agents natively inside Kubernetes rather than adopt a prebuilt one. Especially good for platform engineering teams with specific workflow needs.
Keep
Alert correlationKeep is an open source alert management platform with AI-assisted correlation. It sits more on the AIOps side of the AIOps vs AI SRE line, but it is often deployed alongside AI SRE tools and belongs in any serious landscape.
What it does well
- Centralizes alerts from Prometheus, Grafana, Datadog, Sentry, and many other sources into a single interface.
- AI-assisted correlation to group related alerts into coherent incidents, reducing noise before it reaches an on-call engineer.
- Workflow engine for automating responses to specific alert patterns.
- Self-hostable with Docker, Helm, or standalone deployment options.
- Growing community with regular releases.
Where it falls short
- Alert management is its core strength, not multi-step incident investigation.
- UI and workflow editor are still maturing compared to commercial alert management platforms.
- Requires tuning to get the AI correlation to work well for your specific alert patterns.
Teams drowning in alert noise who want open source correlation and incident grouping, often as a complement to a dedicated AI SRE investigation tool like HolmesGPT.
kubectl-ai
Natural language kubectlkubectl-ai is a Google-maintained open source project that turns plain-language requests into kubectl operations in your terminal. Not a full AI SRE agent, but a critical operational layer that many teams layer onto their incident response workflows.
What it does well
- Natural language to kubectl translation, which speeds up ad-hoc investigation enormously.
- Asks for confirmation before running commands that modify resources.
- Supports multiple model providers.
- Backed by Google, which gives it stability and ongoing maintenance.
- Lightweight and installs with a single command.
Where it falls short
- Not an autonomous investigation agent. A human still drives the questions.
- Tied to kubectl, so coverage outside Kubernetes is limited.
Every Kubernetes team. It is a low-friction addition to any kubectl workflow and pairs well with any of the agents above.
Botkube
ChatOps with AI DoctorBotkube is a ChatOps bot for Kubernetes that posts cluster events to Slack, Discord, Mattermost, or Teams, and runs kubectl and Helm commands from chat. The open source core includes a Doctor plugin that uses AI to explain cluster errors and recommend fixes.
What it does well
- ChatOps-first, so teams can troubleshoot without direct cluster access.
- Open source core with permissive licensing.
- Doctor plugin gives AI-generated answers inline in the chat where incidents are already being discussed.
- Used in production by real teams.
Where it falls short
- The open source repository has been quiet: the last release was in November 2024 and there have been no commits since December 2024. Check its status before you build on it.
- The deep AI features (Botkube Assistant) are commercial, not open source.
- Core is more alerting and ChatOps than full AI SRE.
Teams that run incident response in Slack or Teams and want AI-assisted explanations surfaced in that same channel. Also a good fit for teams that want engineers to be able to troubleshoot Kubernetes without granting them direct cluster access.
kube-copilot
Multi-tool K8s AIkube-copilot is an open source multi-tool for Kubernetes AI SRE work. It combines troubleshooting, security auditing (via Trivy), manifest generation, and action execution into one tool.
What it does well
- Broader surface area than most single-purpose tools. One install gets you troubleshooting, security scanning, and manifest generation.
- Integrates with Trivy for vulnerability scanning, which is useful for teams that want AI-assisted security context during incident response.
- Supports the Model Context Protocol (MCP) for connecting external tools.
Where it falls short
- Jack of several trades, so individual features may not be as deep as specialist tools.
- Smaller community than K8sGPT or HolmesGPT, and a slower release pace: the last release was in April 2025.
- Documentation is still catching up to the feature set.
Small to mid-sized teams that want one tool covering multiple AI-assisted Kubernetes operations without having to stitch together several specialist projects.
SigNoz
Observability with AI awarenessSigNoz is an open source, OpenTelemetry-native observability platform that has evolved into an AI-aware operations tool. It provides logs, metrics, and traces in one interface, with a native MCP server and an AI teammate feature in the cloud version.
What it does well
- OpenTelemetry-native from the ground up, no proprietary agent lock-in.
- Unified view of logs, metrics, and traces, which is the foundation that AI SRE agents need to investigate well.
- Native MCP server means AI agents can query SigNoz data directly as part of their investigations.
- Self-hostable and genuinely open source for the core platform.
- Active maintenance and a strong community.
Where it falls short
- The AI teammate feature is only in the cloud version, not in self-hosted.
- Self-hosted open source is the observability platform without the native AI layer, so teams need to pair it with HolmesGPT, K8sGPT, or their own agent to get full AI SRE capability.
Teams that want an open source observability foundation that is already AI-aware and ready to feed data into agent-based investigation workflows.
GeniA
Slack-based DevOps assistantGeniA is a Slack-based open source ChatOps assistant specifically built for DevOps and SRE tasks. Think of it as a developer-focused AI assistant that lives in Slack and handles deployment, scaling, incident troubleshooting, and security checks on command.
What it does well
- Deeply Slack-native, so it fits teams that already run incident response in chat.
- Covers a range of DevOps and SRE tasks beyond just Kubernetes, including deployments, scaling actions, and security checks.
- Open source and self-hostable.
Where it falls short
- The repository has not had a commit since November 2023 and has no tagged releases, so treat it as a reference design rather than a maintained project.
- Requires meaningful setup to connect it to all the systems it can act on.
- Best as a complement to dedicated observability and investigation tools, not a replacement for them.
SRE and DevOps teams that want a single Slack-native assistant for day to day operational tasks, running alongside a proper investigation tool like HolmesGPT.
Comparison table
| K8sGPT | Kubernetes diagnostics | Low | Apache 2.0 | Sandbox |
|---|---|---|---|---|
| HolmesGPT | Multi-step investigation | High | Apache 2.0 | Sandbox |
| Robusta | Alert enrichment | Low (pairs with HolmesGPT) | MIT | No |
| kagent | Framework to build agents | Depends on what you build | Apache 2.0 | Sandbox |
| Keep | Alert correlation | Medium (correlation) | MIT | No |
| kubectl-ai | Natural language kubectl | Low | Apache 2.0 | No (Google-maintained) |
| Botkube | ChatOps with AI Doctor | Low to Medium | MIT | No |
| kube-copilot | Multi-tool K8s AI | Medium | Apache 2.0 | No |
| SigNoz | Observability with AI awareness | Low (platform, not agent) | MIT | No |
| GeniA | Slack-based DevOps assistant | Medium | Apache 2.0 | No |
- K8sGPT
- Primary focus
- Kubernetes diagnostics
- Agentic depth
- Low
- License
- Apache 2.0
- CNCF status
- Sandbox
- HolmesGPT
- Primary focus
- Multi-step investigation
- Agentic depth
- High
- License
- Apache 2.0
- CNCF status
- Sandbox
- Robusta
- Primary focus
- Alert enrichment
- Agentic depth
- Low (pairs with HolmesGPT)
- License
- MIT
- CNCF status
- No
- kagent
- Primary focus
- Framework to build agents
- Agentic depth
- Depends on what you build
- License
- Apache 2.0
- CNCF status
- Sandbox
- Keep
- Primary focus
- Alert correlation
- Agentic depth
- Medium (correlation)
- License
- MIT
- CNCF status
- No
- kubectl-ai
- Primary focus
- Natural language kubectl
- Agentic depth
- Low
- License
- Apache 2.0
- CNCF status
- No (Google-maintained)
- Botkube
- Primary focus
- ChatOps with AI Doctor
- Agentic depth
- Low to Medium
- License
- MIT
- CNCF status
- No
- kube-copilot
- Primary focus
- Multi-tool K8s AI
- Agentic depth
- Medium
- License
- Apache 2.0
- CNCF status
- No
- SigNoz
- Primary focus
- Observability with AI awareness
- Agentic depth
- Low (platform, not agent)
- License
- MIT
- CNCF status
- No
- GeniA
- Primary focus
- Slack-based DevOps assistant
- Agentic depth
- Medium
- License
- Apache 2.0
- CNCF status
- No
How to pick
If you are running Kubernetes and want the lowest-friction entry point, start with K8sGPT. It will give you AI-assisted diagnostics in a day and does not need a lot of ops investment.
If you want a real investigation agent in open source and you are already running Robusta or willing to adopt it, HolmesGPT is the strongest option today. Pair it with Robusta Open Source for the full stack.
If your pain is alert noise before it reaches engineers, Keep is the right starting point. It pairs well with any of the investigation tools above.
If you want to build your own agent natively inside Kubernetes, kagent is the serious framework for that. Expect to invest engineering time.
If your incident response already lives in Slack or Teams, Botkube and GeniA both fit that pattern well, with different depth tradeoffs. Check how recently each has been maintained before you commit.
If you want faster day-to-day operational workflows while using another tool for deeper investigation, kubectl-ai is an obvious add. Every Kubernetes team should probably install it.
If you need a broader multi-purpose tool rather than specialists, kube-copilot covers more surface area in one install.
If your team needs to rebuild the observability foundation underneath any of these agents, SigNoz is the open source observability platform that is already AI-aware.
Where open source AI SRE is heading in 2026
A few things worth watching over the next few quarters.
Agent frameworks are consolidating. kagent, LangGraph, and similar orchestration layers are making it easier to build custom agents without reinventing the wheel. MCP is becoming the default way agents connect to tools, which means open source agents will be able to plug into more infrastructure out of the box.
Local LLM inference is getting good enough for some SRE tasks. Models running on local hardware via LocalAI or Ollama can handle log analysis and incident correlation without sending data to a hosted API. This matters a lot for regulated industries that cannot send production data to OpenAI or Anthropic.
CNCF adoption is accelerating. K8sGPT, HolmesGPT, and kagent are all in the CNCF sandbox now, which gives the open source AI SRE category more governance credibility than it had a year ago.
The biggest open question is whether a single open source project will emerge as the clear leader, or whether the ecosystem will stay fragmented. For now, teams that want full open source AI SRE capability are typically stitching together two or three of these tools. K8sGPT for quick diagnostics, HolmesGPT plus Robusta for deeper investigation, Keep for alert correlation, and kubectl-ai or Botkube for day-to-day operational speed.
The open source AI SRE ecosystem is real, growing, and genuinely useful. A well-tuned stack of the tools above can handle a huge share of the investigation work for teams that are willing to operate it.
Frequently asked questions
An open source AI SRE tool uses an LLM to help with production operations: reading logs, correlating metrics, investigating incidents and explaining what broke. The code is open, so you can self-host it, run it inside your own perimeter and choose your own LLM provider.
It depends on the problem. HolmesGPT is the strongest open source investigation agent today. K8sGPT is the lowest-friction entry point for Kubernetes diagnostics. Keep is the right start if alert noise is the main pain. Most teams combine two or three of these tools.
Three of the ten are in the CNCF sandbox: K8sGPT, HolmesGPT and kagent.
K8sGPT scans a Kubernetes cluster, detects issues and explains them in plain English. HolmesGPT is an investigation agent: given an alert, it runs multi-step investigations across Kubernetes, Prometheus, Grafana, Loki and other sources to build a root cause hypothesis.
Yes. K8sGPT supports local models through Ollama alongside hosted providers, and HolmesGPT and kubectl-ai support multiple model providers. Local inference through Ollama or LocalAI keeps production data off hosted APIs, which matters for regulated industries.
All ten use permissive licenses: six are Apache 2.0 and four are MIT. Keep and SigNoz are MIT for their core, with a separately licensed ee/ directory, and SigNoz's AI teammate feature is only in its cloud version.
Most are. Two are quiet: Botkube has had no commits since December 2024, and GeniA none since November 2023. Check a project's recent commits and releases before you build on it.
Related reading
Want more on where AI SRE is heading?
Subscribe to Breaking Prod. Outage deep-dives and war stories from the Sherlocks AI team.
Subscribe to Breaking Prod on Substack (opens in a new tab)Evaluating AI SRE tools in general? Read our overview of why AI SRE.