Radar

Product Introduction

1. Definition: Radar is an open-source Kubernetes observability and AI operations (AIOps) platform. It functions as a comprehensive Kubernetes UI and a Model Context Protocol (MCP) server, providing a unified, real-time model of a Kubernetes cluster's state, topology, and change history.
2. Core Value Proposition: Radar exists to accelerate Kubernetes troubleshooting and root cause analysis by providing AI agents with rich, pre-processed cluster context. It enables developers and SREs to diagnose failures up to 3.6x faster and 85% cheaper than dedicated AI SRE tools by leveraging the AI coding assistants they already use, such as Claude Code or Cursor, through the MCP standard.

Main Features

1. AI-Powered Investigations: This feature allows users to initiate a root cause analysis by clicking "Investigate" on any detected issue. Radar orchestrates a read-only session with a local AI agent CLI (e.g., Claude Code, Cursor) or uses its own cloud agent. The agent queries Radar's pre-built cluster model and returns a root cause diagnosis, supporting evidence (logs, events, changes), and a proposed fix. The entire process is designed to complete in about a minute.
2. Unified Cluster Model with Timeline: Radar continuously builds and maintains a live graph of all Kubernetes resources, their relationships (ownership, topology), and a time-indexed log of all specification changes and events. This means an agent's query for "what changed before this broke" is resolved in a single, fast API call, rather than requiring manual correlation of kubectl and kubectl logs outputs.
3. Automated Issue Detection & Ranking: The platform includes a built-in issues engine that proactively scans the cluster model for failures (e.g., CrashLoopBackOff, ImagePullBackOff, configuration drift) and ranks them by severity and potential blast radius. This ranked list serves as the starting point for investigations, eliminating the need for manual symptom discovery.
4. MCP Server for Kubernetes: Radar exposes its cluster model—including resources, changes, logs, and topology—through a standards-compliant Model Context Protocol (MCP) server. This allows any MCP-compatible AI agent (Claude Code, Cursor, GitHub Copilot, etc.) to interact with the Kubernetes cluster using Radar's optimized, context-rich tools instead of raw kubectl commands.
5. Radar Cloud Alert Integration: The hosted SaaS version, Radar Cloud, can automatically trigger an AI investigation whenever a configured alert rule fires. The investigation runs in the cloud with read-only access, and the findings (root cause and evidence) are posted directly to Slack or a webhook alongside the original alert.

Problems Solved

1. Pain Point: Manual Kubernetes troubleshooting is slow and context-switching heavy. Engineers waste time switching between kubectl, log dashboards, Git history, and monitoring tools to piece together what broke and why.
2. Pain Point: Existing AI SRE tools are expensive, slow, and operate as black boxes. They often lack deep integration with the cluster's change history and topology, leading to generic or incorrect diagnoses.
3. Target Audience: Kubernetes Platform Engineers and SREs responsible for cluster reliability and developer support. Software Developers who own services running on Kubernetes and need to debug their own deployments. DevOps Teams seeking to reduce mean time to resolution (MTTR) for production incidents.
4. Use Cases: Diagnosing the root cause of a pod crash-loop within seconds of an alert. Understanding the impact of a recent ConfigMap or Secret change across a complex application topology. Providing on-call engineers with immediate, evidence-backed diagnoses during incidents. Enabling developers to self-serve investigations for their own services without deep kubectl expertise.

Unique Advantages

1. Strengths & Limitations (Pros & Cons):

   • Pros:
     • Performance & Cost: Demonstrated in benchmarks to be 1.6–3.6x faster and 30–85% cheaper than competing AI SRE tools by utilizing existing, optimized AI agents.
     • Agent Agnostic: Works with popular, general-purpose AI coding assistants (Claude, Cursor) via MCP, avoiding vendor lock-in.
     • Rich, Pre-joined Context: Delivers investigations faster by providing agents with a pre-built model of failures, changes, and topology.
     • Safety-First Design: Investigations in the UI and Cloud are read-only by default; fixes run in isolated sessions with protections for GitOps-managed resources.
     • Deployment Flexibility: Open-source core for on-premise/DIY use and a managed Cloud offering for automated alert response.
   • Cons:
     • Agent Dependency: For the open-source UI, requires a compatible local AI agent CLI (Claude Code, Cursor, etc.) to be installed and configured.
     • Learning Curve: While it simplifies troubleshooting, understanding Radar's model and investigation output requires foundational Kubernetes knowledge.
     • Cloud Data Consideration: While OSS runs locally, using Radar Cloud involves sending cluster metadata to Skyhook's systems for investigation processing.

2. Key Alternatives & Differentiation:

   • HolmesGPT / kubectl-ai / AWS DevOps Guru: These are dedicated, closed-source AIOps tools. Radar differentiates by being open-source, agent-agnostic (leveraging user's existing AI tools via MCP), and architected around a real-time cluster model, which benchmarks show leads to higher accuracy on subtle faults. Radar's pricing (OSS free, Cloud likely subscription) contrasts with the often credit-based or enterprise pricing of these tools.
   • Traditional Monitoring (Prometheus/Grafana) + Manual kubectl: This stack provides metrics and logs but lacks correlation and AI synthesis. Radar integrates and contextualizes this data, providing a timeline and topology view, and adds an AI layer for automated analysis, drastically reducing manual effort.
   • Other Kubernetes MCP Servers: Radar's MCP server is uniquely tightly integrated with its issues engine and change timeline, offering tools like get_changes and diagnose that are purpose-built for investigation, rather than just mirroring kubectl commands.

Frequently Asked Questions (FAQ)

1. How does Radar's AI investigation compare to using ChatGPT with kubectl? Radar is fundamentally more efficient and secure. Instead of pasting sensitive kubectl output into a chat, your AI agent uses Radar's MCP server to make structured, read-only queries. Radar provides pre-correlated data (logs with errors highlighted, resources with owners attached, changes on a timeline), which leads to faster, more accurate diagnoses without exposing raw cluster data to a third-party LLM.
2. Is Radar secure for production Kubernetes clusters? Radar employs a layered security model. Its UI and Cloud investigations run in a read-only mode by default. When using the MCP server, write access is configurable and governed by your existing Kubernetes RBAC. Approved fixes run in isolated sessions. Furthermore, Radar explicitly warns before modifying resources managed by GitOps tools like Argo CD or Flux.
3. What happens to my Kubernetes data when using Radar Cloud? For Radar Cloud investigations, a sandboxed job with read-only access to your cluster executes the analysis. An organization owner grants this permission once. The cluster metadata and analysis context are processed by Skyhook's systems to perform the investigation. For the open-source version, all data remains on your infrastructure and queries go to your own AI model provider.
4. Can I use Radar without an AI agent like Claude Code? Yes, but you lose the core AI investigation feature. The open-source Radar UI remains a powerful Kubernetes dashboard with its issues view, topology graph, application grouping, GitOps visualization, and change timeline, all of which are valuable for manual exploration and debugging.
5. How does Radar detect issues and root causes? Radar's engine runs continuous detectors against its live cluster model. These look for known failure modes (e.g., a Pod crash-looping shortly after a ConfigMap change). It ranks issues by correlating symptoms with potential causes from the change timeline. This ranked list is what the AI agent uses as its starting point, making the investigation process significantly more efficient.