Open-Source AI SRE Agents Compared (2026)

An open-source AI SRE is an investigation agent you can run and inspect yourself: it takes an alert or a question, queries your clusters, logs and metrics, and reports a root cause. Six projects come up when people look for one: Aurora, HolmesGPT, K8sGPT, OpenSRE (Tracer), AURA (Mezmo) and kagent. They are not six versions of the same thing. HolmesGPT and Aurora are investigation agents. K8sGPT is a Kubernetes scanner that explains what its analyzers flag. OpenSRE now calls itself an agent for CI/CD reliability. AURA is an agent platform that ships a preconfigured SRE team, and kagent is a framework for running agents you build on Kubernetes.

We ran three of them, Aurora, HolmesGPT and K8sGPT, on the same 19 injected Kubernetes faults, two runs each. OpenSRE, AURA and kagent were not benchmarked. Everything said about those three below comes from their own repositories, docs and homepages, fetched on 2026-11-02 and linked where it is used. Arvo builds Aurora and wrote the benchmark scenarios and grading rules, so read our numbers with that in mind; every transcript and grade is public in Arvo-AI/aurora-lab.

Which open-source AI SRE agents are there?

Repository numbers are from the GitHub API on 2026-11-02. Each "says it is" cell is the project's own wording, from its README or repository description.

Contributors are the count GitHub's contributors API returns for each repository. CNCF status is from each project's cncf.io page; OpenSRE and AURA do not appear in the CNCF landscape data, and Aurora is not a CNCF project.

Where are the other projects ahead of Aurora?

On adoption, the numbers in that table put Aurora near the bottom:

• Stars. OpenSRE has 12,660, about 28 times Aurora's 449. K8sGPT has 8,289, kagent 4,139 and HolmesGPT 3,754. AURA, at 410, is the one project here with fewer.
• Contributors. 362 for OpenSRE, 213 for kagent, 148 for K8sGPT, 75 for HolmesGPT and 23 for AURA, against 12 for Aurora.
• Neutral governance. HolmesGPT, K8sGPT and kagent are CNCF Sandbox projects. Aurora is a single-company project.
• Speed and setup, measured. In our benchmark HolmesGPT's median investigation took 45 seconds against Aurora's 154, and it was faster on all 19 faults. HolmesGPT and K8sGPT each install as one CLI; Aurora is a multi-container application with a web UI, a database, Vault and background workers.
• Coverage, measured. On the fault where two things broke and the alert named only one, K8sGPT reported the second fault in both of its runs. Aurora missed it in both of its runs, and so did HolmesGPT.

How did Aurora, HolmesGPT and K8sGPT do on the same 19 faults?

These are the benchmark totals. The cluster was kind v0.33.0 running Kubernetes v1.37.0, the app a small synthetic shop, and each fault one script in the lab repo.

The 34 against 31 gap is not statistically significant (two-sided Fisher exact test, p = 0.52), and it compares person-checked Aurora grades with judge-only HolmesGPT grades. Our reading: on alert-driven Kubernetes root cause analysis, Aurora and HolmesGPT are roughly even in this lab, and HolmesGPT is about 3x faster. K8sGPT does a different job and belongs next to either of them. K8sGPT ran a different model because it always sends a temperature parameter, which Bedrock rejects for Sonnet 5.

Per-scenario results, the misses and the raw output are in HolmesGPT alternatives, tested, the HolmesGPT review and HolmesGPT vs K8sGPT. The benchmark covers Kubernetes only. It says nothing about cloud APIs, databases or CI pipelines, and two runs per scenario do not measure variance.

Aurora

Aurora takes alerts from PagerDuty, Datadog, Grafana, New Relic, OpsGenie, incident.io and others by webhook, and each one starts an investigation in the background (README). The agent runs kubectl, aws, az and gcloud under an organization-level command policy, writes a postmortem that exports to Confluence, Notion or SharePoint, and can open a fix pull request on GitHub that a person has to approve; nothing merges on its own. A stock install runs a single agent; a multi-agent orchestrator exists but is off by default. It supports OpenAI, Anthropic, Gemini, Vertex AI, OpenRouter, Bedrock and Ollama. Install is make init and make prod-prebuilt from the repo, or a Helm chart.

What it costs you: a heavier install than any CLI here, slower investigations than HolmesGPT in our lab, and a small community.

HolmesGPT

HolmesGPT's README says it "Works with any stack" and lists Kubernetes, VMs, cloud providers, databases and SaaS platforms, with built-in toolsets for Prometheus, Grafana, Loki, Tempo, Datadog, New Relic, Elasticsearch, Kafka, SQL databases, AWS, Azure, GCP and more (README). It fetches alerts from AlertManager, PagerDuty, OpsGenie or Jira and writes findings back. Its stated privacy model: "By design, HolmesGPT has read-only access and respects RBAC permissions." An optional Kubernetes Remediation toolset applies fixes such as scaling and rollbacks, and a newer operator mode runs health checks in the background and, with the GitHub integration connected, "can even open PRs to fix what it finds."

In our lab it was correct in 31 of 38 runs (judge-graded) at a median of 45 seconds. Its own command allow-list blocked kubectl rollout history in 12 runs because holmes ask ran non-interactively; we did not rerun with the command allowed.

Robusta is joining Freshworks. On 2026-10-28 Robusta, the company that created HolmesGPT, announced that it is joining Freshworks. The announcement says: "In practice, little changes today." On 2026-11-02 the HolmesGPT repository was still Apache 2.0 and the CNCF still listed it at Sandbox. We tested 0.43.0, before the announcement.

K8sGPT

K8sGPT runs a fixed set of analyzers over a cluster and asks an LLM to explain each finding. Its README lists "Out of the box integration with OpenAI, Azure, Cohere, Amazon Bedrock, Google Gemini and local models", an --anonymize flag for explanations, an MCP server (k8sgpt serve --mcp) and an operator that runs it in-cluster (README).

It got no alert in our lab and was not scored as an investigator. It named a mistyped image tag in 17 seconds and reported the unalerted second fault that both investigators missed. It printed "No problems detected" on 6 of the 19 faults, in both runs each, while the alert was firing.

OpenSRE (Tracer)

OpenSRE's README describes "a CLI agent that reads the failed run, traces the cause and pushes a fix for you to review. Self-hosted, with your own models." Its homepage is titled "OpenSRE | Open-Source AI SRE Agent Framework", and the headline on the page is "The agent for CI/CD reliability." (opensre.com). The scope goes past CI: the README says it acts "When a CI run fails, an alert arrives, or you ask a question", lists "60+ tools and services" including Kubernetes, AWS, Datadog, Grafana, Alertmanager and PagerDuty, and says it "suggests next steps and, optionally, executes remediation actions" (README).

Facts worth knowing before you install it, all from the README:

• It is labelled "Public Alpha: Core workflows are usable for early exploration, though not yet fully stable."
• "The first launch activates the hosted model", and the interactive shell "only opens for an active account." A self-hosted container is configured with LLM_PROVIDER and its API key.
• "First-party product analytics and Sentry (errors) are opt-out." OPENSRE_NO_TELEMETRY=1 turns them off.

It released v0.1.2026.11.1 and v0.1.2026.11.2 on consecutive days. Not benchmarked. We have not run it on our 19 faults.

AURA (Mezmo)

AURA's README says: "Connect your stack through guided setup, and AURA's preconfigured team of agents starts investigating incidents using the models you already rely on." The agent system (models, specialist agents, prompts, tools, approval policies) is defined in TOML. Configured tool calls can require "webhook or in-conversation approval", with failures "handled fail-closed". It runs OpenAI, Anthropic, Bedrock, Gemini, Ollama or OpenRouter, exports OpenTelemetry traces, reaches Kubernetes, Prometheus, Datadog, PagerDuty, AWS, Azure, GCP and others through MCP servers, and runs as a CLI, a webserver, a Docker image or a Helm chart. The core is Rust (README).

On production use, the README says "AURA began as Mezmo’s internal harness for operating our own SaaS" and that it "powers thousands of agent sessions each month in Mezmo’s hosted observability platform." Not benchmarked. We have not run it on our 19 faults.

kagent

kagent's README calls it "a Kubernetes native framework for building AI agents". An agent is a Kubernetes custom resource that combines a system prompt, tools, subagents and an LLM configuration; agents can run on kagent's own Go or Python ADKs, Codex, Claude or a custom runtime. It ships an MCP server "with tools for Kubernetes, Istio, Helm, Argo, Prometheus, Grafana, Cilium, and others", supports OpenAI, Azure OpenAI, Anthropic, Vertex AI and Ollama, and stores sessions in PostgreSQL (README). It is a CNCF Sandbox project and reached v1.0.0-rc1 on 2026-10-30.

You define the SRE agent yourself, so there is more to build before the first investigation than with a project that ships one. Not benchmarked. We have not run it on our 19 faults.

Which open-source AI SRE should you run?

All six are Apache 2.0, so the cheapest way to choose is to break something on a test cluster and run the candidates yourself. The lab repo breaks a scenario and runs HolmesGPT and K8sGPT against it in three commands. If you maintain OpenSRE, AURA or kagent and want it on the board, the benchmark takes any script that reads a kubeconfig and an alert and prints a root cause; we run it on all 19 faults and publish the result.

How was this comparison made?

• Benchmarked (Aurora, HolmesGPT, K8sGPT). Aurora ran on 2026-10-02, HolmesGPT and K8sGPT on 2026-10-15 and 2026-10-16. A judge model (Claude Opus 5.5) graded every answer against the injected fault; the method, prompts and every limit are on /benchmark and in the lab report. Newer releases of HolmesGPT (0.45.0) and K8sGPT (v0.4.41) are out and have not been retested.
• Not benchmarked (OpenSRE, AURA, kagent). We did not install or run them. Their rows and sections quote their READMEs, homepages and CNCF pages as fetched on 2026-11-02.
• Repository numbers. Stars, contributors, licenses and latest releases from the GitHub API on 2026-11-02. Stars measure attention, not quality.
• Who wrote this. Arvo builds Aurora. We tried to give every project its own words and to put the numbers where Aurora is behind in the table, not in a footnote.

Aurora is on GitHub at github.com/Arvo-AI/aurora, hosted at aurora-ai.net, and you can book a demo to see it on your own alerts.

Benchmark data from results.json. Competitor facts verified against each project's repository, docs and homepage on 2026-11-02.