Radar
Radar's MCP server lets an AI agent inspect, diagnose, and modify a Kubernetes cluster through structured tools for triage, topology, logs, Helm, GitOps, RBAC, audit, and resource mutations.
Triage & diagnosis: rank current failures (
issues), investigate broken workloads/reconcilers with logs/events/changes in one call (diagnose), pull warning events (get_events), and see recent spec/config diffs (get_changes).Inventory & search: dashboard summaries (
get_dashboard), list namespaces/resources/helm releases/packages, and content or CEL-filtered search across cluster objects (search).Drill-down: fetch a resource with relationship context (
get_resource), explore dependency graphs (get_topology,get_neighborhood), and read pod or workload logs with grep/previous/tail options.Operations insight: metrics ranking (
top_resources), static best-practice audit (get_cluster_audit), RBAC blast-radius (get_subject_permissions), and Helm release values/history/diffs (get_helm_release).Mutations (destructive): apply/create YAML manifests (
apply_resource), JSON/merge/strategic patches (patch_resource), restart/scale/rollback workloads, trigger/suspend/resume CronJobs, sync/reconcile/rollback ArgoCD or Flux (manage_gitops), and cordon/drain nodes (manage_node).
Provides support for monitoring ArgoCD GitOps workflows, including viewing status and managing resources.
Provides support for monitoring FluxCD GitOps workflows, including viewing status and managing resources.
Allows management of Helm releases in Kubernetes clusters, including viewing, upgrading, rolling back, and uninstalling releases.
Provides tools for exploring and managing Kubernetes cluster resources, including topology visualization, resource browsing, logs, and exec.
Allows querying Prometheus metrics from Kubernetes clusters for monitoring and visualization.
Allows querying VictoriaMetrics metrics from Kubernetes clusters for monitoring and visualization.
Radar
The missing open-source Kubernetes UI, with a built-in MCP server for your AI agent. Single binary. No account required. Free forever.
🌐 radarhq.io · Docs · Benchmarks · Releases · Slack
Radar shows you what's broken in a Kubernetes cluster, why, and what changed: issues, topology, a timeline of events and resource changes, Helm, GitOps, traffic, audit, and upgrade impact. Your AI agent reads the same cluster data and relationships through Radar's MCP server, and Radar can run an AI investigation for you with the agent CLI you already use. It runs on your laptop as a kubectl plugin or desktop app, or in-cluster with Helm.
AI agents: MCP server and AI investigations — Connect your agent · AI investigations · Benchmarks
Views — Issues · Topology · Resources · Image Filesystem · Timeline · Helm · Compare · TLS · GitOps · Traffic · Metrics · Capacity · Cost · Audit · Network path · Upgrade impact · RBAC · Auth
Install and run in 30 seconds:
curl -fsSL https://get.radarhq.io | sh && kubectl radarOr brew install kubectl-radar. Windows, Krew, desktop app and Helm ↓
Then, with Radar running, connect your AI agent (read-only):
claude mcp add --transport http radar http://localhost:9280/mcp-readonlyCodex, Cursor, GitHub Copilot, other clients, and the desktop app ↓
Why Radar?
Nothing to install in your cluster — a single binary on your laptop that talks to the Kubernetes API with your kubeconfig. No agents, no CRDs, no dependencies
Fast on big clusters — tested on tens of thousands of pods; watches the cluster through informers and pushes live updates to the browser over SSE
Private by design — your cluster data stays on your machine. No account, no agents, no cloud sync. Usage reporting is off unless you opt in, and then sends only anonymous usage counts and coarse cluster facts: Kubernetes version, platform, node-count range, known integrations (what Radar sends). An AI agent you connect sends what it reads to its own model provider
Airgapped-friendly — runs as a single binary against the Kubernetes API and works in locked-down environments with outbound egress blocked
Works everywhere — GKE, EKS, AKS, minikube, kind, k3s, or any conformant cluster
One model of the cluster, for you and your agent — the UI, the MCP server, and AI investigations read the same live data: relationships, health, events, and changes
Ready for teams — deploy in-cluster with Helm for shared access, with SSO (OIDC or an auth proxy) and per-user Kubernetes RBAC in the open-source build
"Have Radar deployed at work. As far as Kubernetes dashboards go, this is one of the best." — u/TheRealNetroxen
Related MCP server: OpenShift SRE Copilot
Debugging in the UI
Start from Issues, a ranked queue of what's broken right now. Open a failing resource to see it in context: its owners, Pods, Services, and config on the Topology, what changed and when on the Timeline (with diffs), and its events, logs, and YAML in the detail drawer. Helm, GitOps, and Traffic cover how it got deployed and who talks to it. When you want help, Investigate hands the same evidence to your agent (AI investigations). Radar records resource changes while it watches the cluster; history is in memory by default, and --timeline-storage=sqlite or postgres keeps it across restarts.
AI agents: MCP server and AI investigations
Pointed at raw kubectl, an agent spends its context window on YAML and its time on round trips. Radar's built-in Model Context Protocol (MCP) server gives it what Radar already knows instead: how resources connect, what is unhealthy, deduplicated events, recent changes with diffs, and filtered logs. In our benchmarks, the same agent and model reached a diagnosis about 3× faster through Radar than through kubectl (details).
Connect your agent
MCP is on by default and served on the same port as the UI: 9280 unless you set --port. The desktop app picks its own port: copy the URL from Radar's MCP dialog and change the final /mcp to /mcp-readonly. Start with the read-only endpoint:
# Claude Code
claude mcp add --transport http radar http://localhost:9280/mcp-readonly
# Codex
codex mcp add radar --url http://localhost:9280/mcp-readonlySetup for Cursor, VS Code (GitHub Copilot), Copilot CLI, OpenCode, Google Antigravity, Kiro, JetBrains, Cline, Devin, Claude Desktop, Zed, Gemini CLI, and any other MCP client is in the MCP guide. Its examples use /mcp; use /mcp-readonly instead to keep Radar's tools read-only. Your agent's other tools follow its own configuration.
Context, not raw YAML — topology, health assessments, events, changes, and logs, minified so they don't burn the context window. The tools cover resources and topology, issues, events and changes, logs, Helm, audit, upgrade readiness, RBAC, cost, and Prometheus
You pick the endpoint —
/mcp-readonlyhas no write tools. The full/mcpendpoint, also on by default, adds write tools (restart, scale, apply, rollback, GitOps sync, node drain) marked destructive so clients can ask before running them. On/mcp,diagnosecan also run an in-cluster reachability probe that creates short-lived pods. Calls use Radar's Kubernetes access: your kubeconfig locally, or each user's own RBAC when authentication is on.--mcp-read-onlyturns/mcpoff (and with it, applying a fix from an AI investigation);--no-mcpturns MCP and AI investigations off. Neither blocks ordinary UI writesSecret values are withheld — Secret reads never include
.dataor.stringData. Environment variables, Helm values, and logs are scrubbed for known secret patterns, which can't catch everything, and the opt-inexec_podtool returns raw command output. See MCP security
AI investigations
Radar can also run the investigation for you, with the agent CLI you already have — Claude Code, Codex, Cursor, or OpenCode — on your machine and signed in with your own account. Radar needs no API key of its own. Start one from a resource's Investigate action, from an issue, by describing what you're seeing on the AI investigations page (where to start, since when, and optionally the resource it's about), or from a terminal against a running Radar:
radar diagnose deploy/checkout -n shop
radar diagnose deploy/checkout -n shop --json > conclusion.jsonEvery investigation ends on the same Findings page, with the evidence behind each claim. Radar's investigation tools can only read the cluster, and Radar applies a fix only when you approve it, from an investigation of the resource it changes. What else the agent can do depends on how Radar runs it. Radar safeguards (Claude Code and Codex) shuts off the agent's other MCP servers and its ability to write. Your agent setup (the only option for Cursor and OpenCode) runs the agent with its normal configuration, tools, and MCP servers, which Radar cannot constrain and which may be able to change your cluster. Cursor and OpenCode approve tool requests automatically in these runs, without asking you. See agents and isolation.
Investigations need a supported agent CLI on the machine running Radar, MCP on, and authentication off. In-cluster installs don't run them. See the AI investigations guide and agent CLI setup.
Benchmarks
Three studies of an AI agent diagnosing live faults from SREGym (Microsoft and UIUC) on a 3-node EKS cluster, with the same judge scoring every tool. Times are averages to a submitted answer, right or wrong. These are our own benchmarks; compare numbers within a study, not across studies.
Study | Faults | Result |
Radar MCP vs raw kubectl — same agent and model | 50 | 64s vs 191s to a diagnosis (about 3× faster); 86% vs 60% diagnosed correctly within two minutes |
Kubernetes MCP servers — Radar, containers/kubernetes-mcp-server, Flux159/mcp-server-kubernetes, Amazon EKS MCP Server, k8sgpt, raw kubectl | 25 | Radar took 57s, 2.3× faster than the next-fastest MCP server; on the 14 faults every tool got right, 33s vs 58s for the next-fastest |
AI SRE tools — Claude Code + Radar MCP vs kubectl-ai, HolmesGPT, OpenSRE, kagent, AWS DevOps Agent | 50 | Claude Code + Radar MCP was the most accurate (44/50 correct), fastest (79s), and cheapest ($0.27 a fault) |
Per-scenario scores and timings are downloadable from the benchmark pages; the AI SRE study also includes costs.
Installation
Quick Install:
curl -fsSL https://get.radarhq.io | shHomebrew:
brew install kubectl-radarAlso available from our tap: brew install skyhook-io/tap/radar.
Then run: kubectl radar. Quick install, PowerShell, Homebrew, and Scoop also set up the radar shorthand. Krew and direct downloads use kubectl radar unless you add your own radar symlink.
CLI
Krew (kubectl plugin manager):
kubectl krew install radarScoop (Windows):
scoop bucket add skyhook https://github.com/skyhook-io/scoop-bucket
scoop install radarPowerShell (Windows):
irm https://get.radarhq.io/install.ps1 | iexCustom install location (macOS/Linux):
curl -fsSL https://get.radarhq.io | INSTALL_DIR="$HOME/.local/bin" shQuick install writes to /usr/local/bin unless INSTALL_DIR says otherwise. The directory is created if missing, and needs to be on your PATH for radar and kubectl radar to resolve.
Direct download — GitHub Releases for macOS, Linux, or Windows.
Desktop App
Native desktop app — no terminal needed.
Homebrew (macOS):
brew install --cask skyhook-io/tap/radar-desktopDebian/Ubuntu — download the .deb from GitHub Releases, then:
sudo apt install ./radar-desktop_*.debFedora/RHEL — download the .rpm from GitHub Releases, then:
sudo dnf install ./radar-desktop_*.rpmLinux (AppImage, any distro) — download the .AppImage from GitHub Releases, then:
chmod +x radar-desktop_*_linux_amd64.AppImage
./radar-desktop_*_linux_amd64.AppImageThe AppImage doesn't update itself. When a new version is out, Radar links to the download.
If the Linux desktop app flashes black, shows black icons or crashes on NVIDIA, see Linux desktop rendering.
Kubeconfig login plugins (exec) run from inside the AppImage, not from the folder you started it in. If a plugin's args name a file by a relative path, such as --token-file token.json, the plugin can't find it and Radar shows "Authentication Failed". Give the full path instead, such as --token-file /home/you/.kube/token.json. A relative command, such as ./token.sh, works: it's looked up next to the kubeconfig file.
Scoop (Windows):
scoop bucket add skyhook https://github.com/skyhook-io/scoop-bucket
scoop install radar-desktopWindows (direct download) — GitHub Releases.
In-Cluster Deployment
Deploy to your cluster for shared team access:
helm repo add skyhook https://skyhook-io.github.io/helm-charts
helm install radar skyhook/radar -n radar --create-namespaceSee the In-Cluster Deployment Guide for Gateway API and ingress exposure, authentication, and RBAC configuration.
Usage
# Opens browser automatically
kubectl radar
# Quick install, PowerShell, Homebrew, and Scoop also set up the bare command
radarCommon flags
Flag | Default | Description |
|
| Path to primary kubeconfig file |
| (context namespace) | Initial namespace filter (supports multi-select in the UI; also used as RBAC fallback for namespace-scoped users). Unset, Radar uses your saved pick, then the kubeconfig context's namespace, then all namespaces |
|
| Server port |
|
| HTTP listen IP address (IPv4 or IPv6), or |
|
| Don't auto-open browser |
|
| Timeline storage backend: |
|
| Disable pod terminal, debug shells, pod file browsing, CloudNativePG sessions and MCP |
|
| Authentication mode: |
|
| Disable all MCP endpoints |
|
| Expose only read-only MCP tools; disable |
The Configuration Guide describes every startup flag in the table above and 27 more, plus tuning for slow or high-latency clusters, kubeconfig precedence, and context switching.
--kubeconfig-dir, --namespaces, --namespace-scope, --base-path, --allowed-hosts, --trusted-origins, --browser, --timeline-db, --timeline-max-size, --history-limit, --disable-helm-write, --disable-local-terminal, --debug-image, --list-page-size, --context-switch-timeout, --first-paint-backstop, --namespace-list-timeout, --max-scope-candidates, --prometheus-url, --prometheus-single-cluster, --prometheus-cluster-label, --prometheus-header, --prometheus-header-from-env, --beyla-job-selector, --opencost-currency, --mcp-catalog-stdio, --version
radar --help is authoritative for the installed version. radar cloud status inspects an in-cluster Radar Cloud installation without changing it (details).
Views
Issues
One ranked queue of what's broken right now — crash loops, image pull failures, stuck rollouts, pods that can't be scheduled, dangling references, and failing Argo CD / Flux conditions — each with an Investigate action. See Issues.
Topology
Interactive graph showing how your Kubernetes resources are connected in real-time.
Two modes: Resources (full hierarchy) and Traffic (network flow path)
Group by namespace, app label, or view ungrouped
Filter by resource kind — click any node for full details
Auto-layout powered by ELK.js, live updates via SSE
Resources
Table-based resource browser with smart columns per resource kind.
Browse all resource types including CRDs
Inspect CRD definitions, versions, instances, and searchable schemas
Search by name, filter by status or problems (CrashLoopBackOff, ImagePullBackOff, etc.)
Add custom columns from any label or annotation — sortable, filterable, and resizable
Click any resource for YAML manifest, related resources, logs, and events
Pod logs list init containers, marked
(init), and open on the init container a Pod is stuck on, so a Pod that never starts still shows whySet regular or init-container images on Deployments, StatefulSets, DaemonSets, and Argo Rollouts, with live rollout progress in tables, drawers, workload views, and Applications
Image Filesystem Viewer
Inspect container image filesystems directly from the Pod view — no need to pull images locally or exec into containers.
Browse, search, and download files from any container image in a Pod
Works with public images (Docker Hub, Quay, GHCR) and private registries (GCR, ECR, ACR) using your cluster's ImagePullSecrets
See Image filesystem.
Timeline
Unified timeline of Kubernetes events and resource changes.
Filter by event type (all or warnings only)
Resource change diffs showing what changed (replicas, images, etc.)
Real-time updates as new events occur
Helm
Manage Helm releases deployed in your cluster — inspect values and rendered manifests, diff revisions, see why an upgrade or hook failed, then upgrade, roll back, or uninstall. Radar tracks available chart upgrades from your configured repos or your own OCI registries. See Helm Support for the detailed behavior and limits.
Compare Resources
Diff any two Kubernetes resources of the same kind side-by-side — like comparing a staging Deployment to its production sibling, or two pods that should be identical but aren't. Server-assigned noise (managedFields, resourceVersion, last-applied) is stripped, and diff-only and spec-only modes cut the rest. See Compare.
TLS Certificate Management
View TLS certificate details and expiry dates across all namespaces — catch expiring certificates before they cause outages.
Parses TLS secrets to show certificate subject, issuer, and validity period
Dashboard-level certificate expiry overview
Available from the resource detail view for any TLS-type Secret
GitOps
Monitor, diagnose, and manage FluxCD and ArgoCD resources in one place.
Fleet view + per-app detail page for ArgoCD (
Application,ApplicationSet,AppProject) and FluxCD (GitRepository,OCIRepository,HelmRepository,Bucket,Kustomization,HelmRelease,Alert)Diagnosis — field-level drift, recent events per resource, stuck-drift-loop detection, parsed operation failures, one-click remediation
Sync, suspend, resume, reconcile, and rollback from the UI or through MCP
See the GitOps guide for the full feature matrix, RBAC requirements, demo cluster, and single-cluster scope notes.
Traffic
Visualize live network traffic between services using Hubble, Caretta, Istio, or Beyla.
Auto-detects Hubble (Cilium), Istio, Caretta, or Grafana Beyla as traffic data sources, with a setup wizard to install one if none is detected
Beyla needs its
networkfeature enabled, and per-port edges additionally needdst.portandtransportnamed inattributes.select— both are off by default, and Radar says so in the Traffic view rather than showing partial edges silentlyAnimated flow graph showing requests per second between services, filterable by namespace, protocol, or status code
Focus on a workload to see only it and what it talks to; the focus is in the URL, so it can be shared
See Traffic for source-specific requirements and large-cluster behavior.
Workload Metrics
Open a Deployment, StatefulSet or DaemonSet's Metrics tab to investigate request rate, HTTP errors, latency, CPU, memory and throttling. Radar reads an existing Prometheus-compatible backend; resource charts do not require HTTP instrumentation, and request charts use supported Beyla or Istio observations.
See Workload metrics for screenshots, prerequisites, supported configurations and local multi-cluster setup limitations.
Capacity (Karpenter)
Read-only diagnosis for Karpenter-managed fleets — why is my pod pending, which NodePool could take it, why aren't my nodes joining, what is disruption doing to my fleet? Appears automatically when Karpenter NodePools are detected (RBAC-gated). Overview, NodePool detail, Demand, and Activity screens; every quantity carries its certainty (= ≥ ≤ ?), so unavailable is never shown as zero. See docs/capacity.md.
Cost Insights
Track Kubernetes spending from OpenCost metrics in a PromQL-compatible backend or a Kubecost 3 Aggregator: allocated workload cost, namespace and workload breakdowns with efficiency scoring, node costs, and trends when Prometheus history is available. Appears automatically when compatible data is detected. See Cost.
Cluster Audit
Proactive best-practices scanner with 48 checks across security, reliability, and efficiency — inspired by Polaris, Kubescape, Trivy, and NSA/CISA guidelines. Runs instantly against cached data with zero cluster-side installation.
Security: privileged containers, privilege escalation, host namespaces, runtime socket mounts, secrets in ConfigMaps, and more
Reliability: missing probes, image tag
latest, single-replica deployments, missing PDB/topology spread, deprecated API versions, CloudNativePG clusters with no backup destination, no WAL archiving, a single instance or the deprecated in-tree Barman backupEfficiency: missing requests and limits, orphan ConfigMaps/Secrets, PVCs with no consumer observed, long-Pending PVCs, and Released or Failed PVs
Remediation guidance per finding, NSA/CISA and CIS framework labels, and per-resource opt-out via the
radarhq.io/ignore-checksannotation
See Cluster audit and audit configuration.
Network Path Diagnose
Hop-ordered diagnosis for Service, Ingress, HTTPRoute, GRPCRoute, and Gateway — answering "if traffic is sent toward this resource, does it reach a healthy process, and if not which hop breaks first?" It names the first broken hop with a kubectl reproducer, predicts NetworkPolicy blocks, and can run an optional DNS / TCP / TLS / HTTP probe from your laptop or in-cluster. Open the Reachability tab on the resource; see docs/reachability.md.
Kubernetes Upgrade Impact
Open Checks → Upgrade impact before upgrading the control plane. Radar compares the current cluster with a target Kubernetes minor and orders evidenced compatibility, health, admission, drain, runtime, and configuration checks by required action — APIs removed in the target release, kubelet and kube-proxy skew, overlapping PodDisruptionBudgets, removed feature gates — using live resources, Helm release manifests, last-applied configuration, and API server metrics. On k3s and RKE2 it also lists the system-upgrade-controller Plans that upgrade the distribution, with their version and state.
See the Kubernetes upgrade impact guide for the check catalog, coverage semantics, and RBAC notes.
Vulnerabilities in Deployed Images
With Trivy Operator installed, Checks → Vulnerabilities rolls its VulnerabilityReports up to the images that run now: which images carry Critical and High CVEs, which have a fix, and which workloads and namespaces run them, by image, by CVE or by workload. By fix turns the fixable findings into a list of package upgrades: each row says what to upgrade to and every CVE that clears. Reports about older revisions are left out, an image used by many workloads is one row, and running images without a report are listed as not scanned rather than clean. The tab appears only when the cluster serves Trivy's VulnerabilityReport kind. See Trivy Operator.
Access Control (RBAC visibility)
Inspect what any ServiceAccount can actually do — without three kubectl describe calls.
ServiceAccount, Role, and binding details: direct and inherited bindings, effective permissions, and the Pods that use a ServiceAccount
Pod and workload Permissions: the most-permissive rules the Pod's ServiceAccount grants, with a blast-radius alert for wildcards, cluster-admin, escalation verbs, or cluster-wide
create pods"My Permissions" panel: a live
SelfSubjectRulesReviewfor the current user, for fast "why can't I do X" debugging
See Access control.
Authentication
For shared in-cluster deployments, Radar supports optional user authentication with per-user Kubernetes RBAC.
Proxy mode — works with oauth2-proxy, Pomerium, Cloudflare Access, or any auth proxy that sets forwarded headers
OIDC mode — built-in login via Google, Okta, Dex, Keycloak, or any OIDC provider
Per-user namespace scoping and write authorization via K8s impersonation
UI adapts automatically — buttons only appear if the user has RBAC permission
No auth by default (local use). See the Authentication Guide for setup.
Supported Resources & Integrations
Radar auto-discovers any CRD in your cluster. Popular tools get dedicated integrations with resource views, topology, AI context and application evidence. Coverage varies by integration.
The Helm chart grants read access to common built-in Kubernetes kinds; Secrets, RBAC objects and CertificateSigningRequests depend on chart settings and the authentication mode. CRD-based integrations need the CRD installed in your cluster and read access; most API groups are granted by default, and the chart's RBAC and CRD access sections list what is on, what is opt-in, and how to add rules.
Category / integration | Coverage |
Workloads | Deployments, DaemonSets, StatefulSets, ReplicaSets, Pods, Jobs, CronJobs |
Networking | Services, Ingresses, NetworkPolicies, Endpoints, EndpointSlices, PodDisruptionBudgets |
Configuration | ConfigMaps, Secrets (names only, values hidden), LimitRanges, ResourceQuotas |
Storage | PersistentVolumeClaims, PersistentVolumes, StorageClasses |
Autoscaling | HorizontalPodAutoscalers, VerticalPodAutoscalers |
Cluster | Nodes, Namespaces, ServiceAccounts, Events |
Other Kubernetes APIs | CertificateSigningRequests; Workloads, PodGroups, CompositePodGroups, PodCertificateRequests, ClusterTrustBundles (only when served by the cluster) |
GitOps (FluxCD) | GitRepository, OCIRepository, HelmRepository, Kustomization, HelmRelease, Alert |
GitOps (ArgoCD) | Application, ApplicationSet, AppProject |
Argo Rollouts | Rollout |
Argo Workflows | Workflow, WorkflowTemplate |
ConfigMap/Secret reflection details, source and mirror relationships, recorded copy evidence | |
cert-manager | Certificate, CertificateRequest, Order, Challenge, Issuer, ClusterIssuer |
Gateway API | Gateway, GatewayClass, HTTPRoute, GRPCRoute, TCPRoute, TLSRoute, UDPRoute |
Istio | VirtualService, DestinationRule, Gateway, ServiceEntry, PeerAuthentication, AuthorizationPolicy |
Traefik | IngressRoute, IngressRouteTCP, IngressRouteUDP, Middleware, MiddlewareTCP, TraefikService, ServersTransport, ServersTransportTCP, TLSOption, TLSStore |
Contour | HTTPProxy |
Knative Serving | Service, Configuration, Revision, Route, DomainMapping |
Knative Eventing | Broker, Trigger, EventType, Channel, InMemoryChannel, Subscription |
Knative Sources | PingSource, ApiServerSource, ContainerSource, SinkBinding |
Knative Flows | Sequence, Parallel |
Knative Networking | Ingress, Certificate, ServerlessService |
Karpenter | NodePool, NodeClaim (+ provider-specific NodeClasses via auto-discovery) |
OpenTelemetry Operator | OpenTelemetryCollector and Instrumentation: reconciliation, configured pipelines and injection settings |
System Upgrade Controller | Plan: per-node upgrade progress, an Issue for an invalid Plan, and k3s/RKE2 upgrade Plans on the Upgrade impact page |
Flagger | Canary and MetricTemplate: recorded rollout state, target/autoscaler/template links and failed-rollout Issues |
KEDA | ScaledObject, ScaledJob, TriggerAuthentication, ClusterTriggerAuthentication |
Prometheus Operator | ServiceMonitor, PodMonitor, PrometheusRule, Alertmanager |
Security (Trivy) | VulnerabilityReport, ConfigAuditReport, ExposedSecretReport, ClusterComplianceReport, SbomReport, RbacAssessmentReport, InfraAssessmentReport |
Strimzi | KafkaConnector failure evidence (connector/task status) |
Node-reported disk and memory alarms - local collection | |
JetStream consumer backlog, acknowledgment-pending and redelivery counters - local collection | |
Velero | Backup, Restore, Schedule, BackupStorageLocation, VolumeSnapshotLocation |
External Secrets | ExternalSecret, ClusterExternalSecret, SecretStore, ClusterSecretStore |
CSI Volume Snapshots | VolumeSnapshot, VolumeSnapshotContent and VolumeSnapshotClass: readiness, errors, restore size, source, binding and deletion policy |
Secrets Store CSI Driver | SecretProviderClass and Pod mounts: mount state, object versions and synced Secrets in the Pod drawer |
Initialization, seal and standby state - local collection | |
CloudNativePG | Cluster, Backup, ScheduledBackup, Pooler, Database, Publication, Subscription, ImageCatalog, ClusterImageCatalog, ObjectStore — plus dedicated views for fleet, protection and declaration triage |
Crossplane | Managed Resources (any provider), Composite Resources, Claims, Provider, ProviderConfig, Function, Configuration, Composition, CompositionRevision, XRD |
Kyverno | Policy, ClusterPolicy, PolicyReport, ClusterPolicyReport |
Sealed Secrets | SealedSecret |
Dynamic Resource Allocation | ResourceClaim, ResourceClaimTemplate, DeviceClass, ResourceSlice (resource.k8s.io, K8s 1.32+) |
NVIDIA GPU Operator | ClusterPolicy, NVIDIADriver |
Calico | NetworkPolicy, GlobalNetworkPolicy, StagedNetworkPolicy, StagedGlobalNetworkPolicy, StagedKubernetesNetworkPolicy, IPPool, HostEndpoint, Tier |
Kueue | ClusterQueue, LocalQueue, Workload, ResourceFlavor, AdmissionCheck (+ Cluster Autoscaler ProvisioningRequest) — basic |
KubeRay | RayCluster, RayJob, RayService, RayCronJob — basic |
KServe | InferenceService, ServingRuntime, ClusterServingRuntime, InferenceGraph, TrainedModel, LLMInferenceService — basic |
Inference Gateway | InferencePool (v1 + alpha groups), InferenceObjective — basic |
Batch | LeaderWorkerSet, JobSet, Volcano (Job/Queue/PodGroup/JobFlow/JobTemplate), Kubeflow (PyTorchJob/TFJob/MPIJob/TrainJob) — basic |
KAI Scheduler | Queue, PodGroup — basic |
Model serving | KAITO (Workspace, RAGEngine), NVIDIA NIM (NIMService/NIMCache/NIMPipeline), AMD GPU Operator (DeviceConfig) — basic |
Agent runtimes | Agent Sandbox and Agent Substrate: sandbox and WorkerPool status read the way their controllers mean it, Issues for stuck sandboxes and broken pools, and with Prometheus a WorkerPool capacity verdict and a Node snapshot-upload verdict with charts |
Cost (OpenCost / Kubecost) | Namespace/workload/node cost via compatible Prometheus metrics or the Kubecost 3 Aggregator (no CRDs) |
CRDs | Any Custom Resource Definition in your cluster (auto-discovered) |
Local runtime evidence
When Radar runs locally, use Collect RabbitMQ evidence, Collect NATS evidence or Collect Vault evidence in resource details to select a Pod and collect explicitly. MCP clients can also collect after operator approval.
These observations describe one Pod endpoint, not overall application health, and do not add automatic Issues detection. See the collection requirements and limitations.
Keyboard Shortcuts
Radar is keyboard-first: ? lists every shortcut, ⌘K opens the command palette, / focuses search, and g followed by a letter switches views (g i Issues, g t Topology, g l Timeline, g r Resources). The full list is in the keyboard shortcuts reference.
Security
Radar reads your cluster through your own credentials and keeps cluster data local. It does not upload manifests, logs, events, metrics, or resource data to Skyhook, and it does not require an account, agent, or cloud backend. When you connect an AI agent or run an AI investigation, what Radar returns goes to that agent and its model provider. Found a vulnerability? Please report it privately to security@skyhook.io — see SECURITY.md for the process and response timelines.
Community and support
Slack is the fastest way to get help. Ask in
#radar-help, share feedback, and talk Kubernetes with the Radar team and other users.GitHub Discussions for ideas and longer questions you want others to find later.
GitHub Issues for bugs and feature requests.
Development
See the Development Guide for building from source and contributing. For automation and integrations, see the HTTP API reference.
Quick start:
git clone https://github.com/skyhook-io/radar.git
cd radar
make deps
# Terminal 1: Frontend with hot reload (port 9273)
make watch-frontend
# Terminal 2: Backend with hot reload (port 9280)
make watch-backendContributing
Contributions are welcome! Please read our Contributing Guide for details on the development workflow, pull request process, and coding standards.
Questions about a change? Ask in Slack before you start, or open a Discussion.
About
Radar is built and maintained by Skyhook (YC W23) and is open source under Apache-2.0. The OSS version is fully featured and the recommended way to run Radar.
For teams that want hosted multi-cluster Radar, with fleet views, alerts, and shared links, we also offer Radar Cloud.
License
Apache 2.0 — see LICENSE
Available Tools
25 toolsapply_resourceADestructive
Create or update a Kubernetes resource from a YAML manifest. In 'apply' mode (default), performs a server-side apply with FieldManager=radar and reports field ownership conflicts instead of taking ownership by default. Set force=true only when you intend to take field ownership from other managers (Helm, Flux, GitOps controllers, kubectl). In 'create' mode, performs a strict create that fails if the resource already exists. Supports multi-document YAML separated by '---'. Use dry_run to validate without persisting changes and preview the server-side result. Multi-document failures return per-document status because earlier documents may already be applied. By default returns compact post-mutation state, submitted-vs-live spec differences, rollout/pod status for workloads, and current related issues; set verify=false only when you need a terse write result.
Inputs: yaml (required), mode, force, verify, +2 more.
diagnoseARead-only
Use when the agent's decision is 'this workload or GitOps reconciler is broken — find the root cause / localize the failure'. For a single Pod/Deployment/StatefulSet/DaemonSet, bundles: the resource (Kubernetes-shaped detail) + diagnostic resourceContext (managedBy, exposes, selectedBy, uses, runsOn, issue/audit/policy rollups) + current AND previous container logs across the workload's pods + recent Warning events filtered to this resource + a recentChanges section for the workload and directly referenced ConfigMaps (no Secret content) + a startupBlockers section when the workload can't reach Running (unschedulable with the offending node constraint named, admission/quota rejection, or a post-bind CNI/volume stall). For Application/Kustomization/HelmRelease, returns the reconciler resource + GitOps status summary + related parsed issues (cause/action/remediation), without pod-log fan-out. Use for CrashLoopBackOff, OOMKills, failed deploys, image-pull errors, readiness flaps, scheduling failures, error-spewing services, GitOps sync/health failures, or any workload root-causing where you would otherwise call get_resource → events → get_pod_logs → get_pod_logs(previous=true) in sequence — this returns the same data in one round-trip. If you only need ONE facet (e.g. just spec, just logs), prefer the targeted tool. For other CRDs or non-workload kinds, use get_resource (with optional include=events).
Inputs: kind (required), name (required), namespace (required), since, +2 more.
get_changesARead-only
Use when the symptom is 'this worked earlier' or 'something broke after a deploy/config change.' Returns recent meaningful changes ranked with spec/config changes first, including field-level diffs for Deployment env/probes and structured ConfigMap data when available. This is often faster than reading ReplicaSet histories or individual audit/log streams, especially when issues are empty or dominated by baseline failures. Pair with since to bound the window; filter by namespace, kind, or name when you know the scope. Omit namespace when the relevant change may be outside the app namespace.
Inputs: kind, name, limit, since, +1 more.
get_cluster_auditARead-only
Use when the agent's decision is 'is this cluster well-configured / compliant?' — STATIC CONFIG POSTURE, not live operational state. Returns best-practice findings: Security (runAsRoot, privileged containers, dangerous capabilities, hostPath/hostNetwork, secret-in-ConfigMap), Reliability (single replicas, missing PDB, missing TopologySpread, podHARisk, Service/Ingress without matching backends, stuckTerminating, deprecatedAPIVersion), and Efficiency (missing resource requests/limits, orphaned ConfigMaps/Secrets, under/over-utilization). Each finding has remediation guidance. INDEPENDENT of operational health: a healthy pod can have many audit findings (badly configured but working), a crashing pod can have zero (cleanly configured but failing). For 'what's broken right now?' use the issues tool. Respects user's audit settings (ignored namespaces, disabled checks). Filter by namespace, category, or severity. Resources absent from findings should NOT be reported as non-compliant — empty findings for a scope means no violations, not a failed check.
Inputs: limit, category, severity, namespace.
get_dashboardARead-only
Use for inventory-style cluster or namespace health triage, like kubectl get all plus detected problems and warning events in one call. Returns resource counts, failing pods, unhealthy workloads, recent Warning events, and Helm release status so you can rank likely suspects before calling get_resource or logs. Routing: unknown broken thing -> issues; content/name search -> search; service routing/dependencies -> get_topology or get_neighborhood; inventory/counts/Helm/events overview -> get_dashboard. Use namespace for app-local triage; omit it when the root may be cluster-scoped.
Inputs: namespace.
get_eventsARead-only
Use for recent Kubernetes Warning events after an overview points at a namespace or resource, or when the symptom is scheduling, pulling images, restarts, failed mounts, readiness, or controller errors. Events are deduplicated and sorted by recency with reason, message, and count. For a ranked issue list that includes problems/conditions, use issues first.
Inputs: kind, name, limit, namespace.
get_helm_releaseARead-only
Get detailed information about a specific Helm release including owned resources and their status. Optionally include values, revision history, or manifest diff between revisions using the 'include' parameter (comma-separated: values, history, diff). diff_revision_1 and diff_revision_2 are only used when include contains diff.
Inputs: name (required), namespace (required), include, diff_revision_1, +1 more.
get_neighborhoodARead-only
Use when investigating cross-resource failures around a known resource: service routing, targetPort/selector/endpoints problems, dependency timeouts, config/secret refs, owner chains, or traffic not reaching pods. Returns the BFS-expanded topology neighborhood around one root, which is usually cheaper and clearer than get_topology once you have a suspect. Typical flow: issues/search/list_resources identify a Service or workload, then get_neighborhood traces its upstream/downstream Services, workloads, Pods, refs, and owners. Profile auto (default) picks a bounded edge set from the root kind; profile all expands every edge type and is heavier, use it only when auto produced a too-narrow neighborhood. Hops defaults to 1 and maxes at 2. Nodes are RBAC-filtered; denied neighbors appear only as aggregate omitted counts.
Inputs: kind (required), name (required), hops, group, +3 more.
get_pod_logsARead-only
Use only after narrowing to a specific Pod/container. Returns diagnostically relevant log lines (errors, panics, stack traces, warnings) or falls back to recent tail lines. Set grep to server-side filter like kubectl logs | grep PATTERN when you know an error string, request path, service name, or trace id. For broad incidents, first use issues, get_dashboard, search, list_resources, or get_neighborhood to avoid reading logs from many unrelated pods. If the target is a config value, feature flag, CRD field, env ref, or YAML/spec content, use search rather than logs.
Inputs: name (required), namespace (required), grep, since, +3 more.
get_resourceARead-only
Use AFTER narrowing to one resource. Returns the resource's Kubernetes-shaped spec/status/metadata plus resourceContext when available (relationships, refs, issue/audit/policy rollups). This is the drill-down tool, not the best first call for broad incidents. Start with issues, get_dashboard, search, or list_resources to rank candidates; then call get_resource for the exact object. If you are looking for a string across ConfigMaps, CRD specs, env refs, or object content, use search instead of fetching resources one by one. Use the group parameter for ambiguous kinds such as Knative Service vs core Service.
Inputs: kind (required), name (required), group, context, +2 more.
get_subject_permissionsARead-only
Get the effective RBAC permissions of a Kubernetes subject (ServiceAccount, User, or Group) — what can this principal do across the cluster. Returns: the bindings that grant access (each pointing at its Role/ClusterRole), a deduplicated flat rule list, and (for ServiceAccounts) the Pods running as this SA. Use this to answer 'is this SA over-privileged?', 'why can X do Y?', or 'what's the blast radius if this Pod is compromised?'. For ServiceAccount, namespace is required. For User/Group, omit namespace (those are external identities, not namespaced resources). Inherited grants from implicit group memberships (system:authenticated, system:serviceaccounts) are included for ServiceAccount subjects with the inheritedFromGroup field set per binding so you can distinguish direct from inherited grants.
Inputs: kind (required), name (required), namespace.
get_topologyARead-only
Use to map a multi-service incident or dependency graph, preferably scoped to a namespace. Returns Kubernetes resource nodes and edges (Services, workloads, Pods, Ingresses, ConfigMaps, Secrets, owners) so you can see service-to-workload traffic and ownership relationships instead of inspecting resources one by one. Use view=traffic for routing/connectivity questions and view=resources for ownership/deployment hierarchy. Always specify namespace unless you specifically need a cross-namespace graph. If you already know the suspicious root, use get_neighborhood for a smaller focused graph.
Inputs: view, format, namespace.
get_workload_logsARead-only
Get aggregated logs from all pods of a workload (Deployment, StatefulSet, or DaemonSet). Logs are collected from all matching pods concurrently, then server-side filtered to errors, warnings, panics, and stack traces using deterministic regex patterns and deduplicated. Set grep for additional server-side filtering before that summary stage, like kubectl logs | grep PATTERN. More useful than get_pod_logs when you need logs across all replicas of a workload. If the target is a config value, feature flag, CRD field, env ref, or YAML/spec content, use search rather than logs.
Inputs: name (required), namespace (required), grep, kind, +4 more.
issuesARead-only
Use when the agent's decision is 'what's broken right now?' — LIVE OPERATIONAL STATE, not config posture. Returns a ranked list of currently failing resources: failing Deployments/StatefulSets/CronJobs/HPAs/Nodes/Jobs/PVCs, dangling-reference errors like Pod→missing PVC/CM/Secret/SA, HPA→missing scaleTargetRef, Ingress→missing backend Service, RoleBinding→missing Role, webhook→missing Service, pod startup blockers — why a Pod can't reach Running: unschedulable (arch/taint/resources/affinity), admission-rejected (quota/PodSecurity/webhook), or stuck post-bind (CNI/volume), and False .status.conditions on CRDs from Argo/Flux/Knative/Crossplane/cert-manager/KEDA. Severity normalized to critical/warning. This is one curated stream — there is no source filter; each row carries a source label (problem|missing_ref|scheduling|condition) you can slice on via the CEL filter= if needed. Some rows include diagnostic_context: deterministic facts such as explicit missing refs, selected backend issues, or workload rollups; treat these as triage context, not proof of root cause. When recent_changes is present, consider it if the issue list does not explain the reported symptom; recent_changes_reason says why Radar attached it. It lists recent spec/config changes that may explain failures not yet visible as runtime issues, or help distinguish creation-time baseline failures from the active incident. For raw Kubernetes Warning events use get_events; for static best-practice / security-posture findings (runAsRoot, missing PDB, no probes, missing resource limits) use get_cluster_audit — a separate axis that must never be conflated (a healthy pod can have many audit findings; a crashing pod can have zero). Kyverno PolicyReport violations are not in either — they surface per-resource via get_resource's resourceContext policy rollup. After identifying a suspect issue, call diagnose when the affected resource is a workload (Pod/Deployment/StatefulSet/DaemonSet) or GitOps reconciler (Application/Kustomization/HelmRelease). For other non-workload kinds, call get_resource. Use get_neighborhood when the failure likely crosses Services/workloads/Pods/dependencies. Use namespace for app-local triage; omit it when the root may be cluster-scoped or outside the app namespace.
Inputs: kind, limit, filter, severity, +1 more.
list_helm_releasesARead-only
List all Helm releases in the cluster with their status and health. Returns release name, namespace, chart, version, status (deployed/failed/pending), and resource health (healthy/degraded/unhealthy). Use to get an overview of what's deployed via Helm before inspecting individual releases.
Inputs: namespace.
list_namespacesARead-only
List all Kubernetes namespaces with their status. Use to discover available namespaces before filtering other queries.
list_packagesARead-only
List installed packages (Helm releases, label-managed workloads, CRDs, Argo Applications, Flux HelmReleases + Kustomizations) with their sources, versions, and health. Each row carries a sources array (H=Helm API, L=workload labels, C=CRD registrations, A=Argo declaration, F=Flux declaration) so the caller can see WHY this package is detected; the MCP response also includes sourceLegend mapping those stable codes to readable meanings, plus a contributors array with per-source detail (each source's view of health/version, plus the GitOps controller resource identity in declarationName/declarationNamespace for sources A and F). Aggregated row-level health is worst-of contributors; row-level version is first-source-priority — read contributors to detect same-cluster disagreement. Use to answer 'what's installed?' / 'what version of cert-manager is running?' / 'are there orphaned operators?' in a single call instead of combining list_helm_releases + list_resources + manual merge. Filter by namespace, source, or chart substring. Response includes sourcesErrored listing any sources that failed (e.g. RBAC denied for Helm release secrets, Helm client not initialized, GitOps informer errors other than the controller's CRDs being absent). When this is non-empty, results are still returned but are partial — fewer rows than expected may indicate a dropped source rather than nothing installed. ArgoCD/FluxCD CRDs that are simply not installed in the cluster do NOT appear in sourcesErrored.
Inputs: chart, source, namespace.
list_resourcesARead-only
Use for a jq-like namespace sweep when you know the resource kind (pods/po, deployments/deploy, services/svc, configmaps/cm, CRDs). Returns compact Kubernetes-shaped rows plus summaryContext by default (managedBy, health, issueCount) so you can compare many similar resources and pick suspects before calling get_resource. For unknown kind/name searches, use search. For broad health triage, use get_dashboard or issues first.
Inputs: kind (required), group, context, namespace.
manage_cronjobADestructive
Perform operations on a Kubernetes CronJob. Supported actions: 'trigger' creates a manual Job run from the CronJob's template, 'suspend' pauses the CronJob schedule (no new Jobs will be created), 'resume' re-enables a suspended CronJob's schedule.
Inputs: name (required), action (required), namespace (required).
manage_gitopsADestructive
Perform operations on GitOps resources (ArgoCD or FluxCD). For ArgoCD: actions are 'sync' (trigger deployment), 'refresh', 'terminate', 'rollback', 'suspend' (disable auto-sync), 'resume' (re-enable auto-sync). Resource kind is always Application. For FluxCD: actions are 'reconcile' (trigger sync), 'sync-with-source', 'suspend', 'resume'. Requires 'kind' parameter (kustomization, helmrelease, gitrepository, etc.).
Inputs: name (required), tool (required), action (required), namespace (required), +8 more.
manage_nodeADestructive
Perform operations on a Kubernetes node. Supported actions: 'cordon' marks the node as unschedulable (no new pods will be scheduled), 'uncordon' marks the node as schedulable again, 'drain' cordons the node and evicts all non-DaemonSet pods. Drain options: 'delete_empty_dir_data' (allow evicting pods with emptyDir volumes), 'force' (evict pods not managed by a controller), 'timeout' (seconds, default 60).
Inputs: name (required), action (required), force, timeout, +1 more.
manage_workloadADestructive
Perform operations on a Kubernetes workload (Deployment, StatefulSet, or DaemonSet). Supported actions: 'restart' triggers a rolling restart, 'scale' changes the replica count (requires 'replicas' parameter), 'rollback' reverts to a previous revision (requires 'revision' parameter). Use list_resources or get_dashboard first to identify the target.
Inputs: kind (required), name (required), action (required), namespace (required), +2 more.
patch_resourceADestructive
Patch one existing Kubernetes resource with JSON Patch, JSON Merge Patch, or strategic merge patch. Use this for precise field/list mutations such as removing a bad dnsConfig, hostPort, initContainers field, sidecar container, nodeSelector, or replacing one scalar value. Prefer this over apply_resource when you know the exact field to mutate and do not want to rewrite the full manifest or take broad server-side-apply ownership. For patch_type=json, patch must be an RFC 6902 JSON Patch array. For patch_type=merge, patch must be a JSON object. For patch_type=strategic, use a JSON object against built-in Kubernetes kinds when you need name-keyed list merging, such as editing one container. By default returns compact post-patch state and dry-run preview diffs; JSON Patch calls also include per-operation field checks. Set verify=false only when you need a terse write result.
Inputs: kind (required), name (required), patch (required), group, +4 more.
searchARead-only
Find resources by content/term match when you do not know which object contains a string, config key, env ref, image, label/annotation value, ConfigMap data, CRD field, or status message. Tokens are AND'd. Secret content is intentionally NOT indexed — Secret names match by metadata, but data values won't appear in snippets to avoid leaking secret material through search results. Examples: readinessProbe user-service, image:flagd, kind:Pod label:app=cart error. Modifiers such as kind:Pod, ns:foo, label:app=bar, and image:redis narrow a term match; modifier-only queries are enumeration, so use list_resources when you already know the kind/namespace. Returns ranked hits with snippets and summaryContext. Use CEL filter for structural predicates. Searches typed kinds plus warmed CRDs; cold CRDs need list_resources first.
Inputs: query (required), limit, filter, context, +1 more.
top_resourcesARead-only
Use when investigating high CPU, memory pressure, OOMKills, slow services, noisy pods, or uneven node load. Returns live metrics ranked like kubectl top pods|nodes | sort, joined with Kubernetes context: pod status, readiness, restarts, owner workload, requests, and limits. kind=pods ranks individual Pods, kind=workloads aggregates Pods to Deployments/StatefulSets/DaemonSets/Jobs, and kind=nodes ranks Nodes. Use before reading logs when the symptom mentions CPU, memory, GC, OOM, latency, or load.
Inputs: kind, sort, limit, namespace.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 25 tools
Each tool targets a distinct concern: get_dashboard and issues for triage, diagnose for deep root-cause, get_pod_logs vs get_workload_logs for log scope, search for content lookup, and manage_* for explicit actions. Even where overlap exists (e.g., diagnose bundles get_resource+events+logs), the descriptions explicitly tell the agent which to use and when, eliminating ambiguity.
The majority follow a clear verb_noun pattern: get_* for reads, list_* for enumeration, manage_* for actions, apply_resource/patch_resource for writes. Minor deviations like 'issues' and 'diagnose' act as situational verbs (state analysis) and are still distinct and readable, so the set remains predictable overall.
25 tools is at the heavy end of the recommended range, but the breadth is justified for a Kubernetes diagnostics platform covering reads, writes, logs, metrics, events, RBAC, Helm, GitOps, and topology. Each tool serves a unique purpose with no gratuitous duplication, so the count is appropriate for the domain's complexity.
The surface covers discovery (list_*, search), troubleshooting (issues, diagnose, logs, events, metrics), management (apply/patch, manage_*), and specialized views (topology, neighborhood, RBAC, GitOps). The most notable gap is the absence of a delete resource tool, but the read/manage/act coverage is strong enough that agents won't hit dead ends.
Maintenance
Related MCP Connectors
The Google GKE MCP server is a managed Model Context Protocol server that provides AI applications with tools to manage Google Kubernetes Engine (GKE) clusters and Kubernetes resources. It exposes a structured, discoverable interface that allows AI agents to interact with GKE and Kubernetes APIs, enabling them to inspect cluster configurations, retrieve Kubernetes resource YAMLs, monitor operations like cluster upgrades, diagnose issues, and optimize costs—all without needing to parse text output or use complex kubectl commands.
MCP observability. Query live traffic, errors, duration, and alerts from your AI agent.
Autonomous and governed SRE & MLOps control plane for AI agent platforms.
The Cortex MCP server provides read-only access to real-time engineering context from the Cortex developer portal, allowing AI coding assistants to answer natural language questions about your organization's catalog (microservices, libraries, domains, teams, infrastructure), scorecards (engineering standards and best practices), initiatives (goals and deadlines), and Engineering Intelligence metrics. It includes tools for querying documentation, tracking personal entities, and accessing AI-assisted insights across the entire Cortex ecosystem.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceAn open source MCP server empowering SREs with intelligent observability, predictive analytics, and AI-driven automation across Kubernetes, OpenShift, and Tekton environments.78 PyPI11Apache 2.0
- AlicenseAqualityDmaintenanceAI-powered MCP server for enterprise OpenShift/Kubernetes cluster management, providing diagnostic tools, RAG knowledge retrieval, and autonomous remediation recommendations.9MIT
- AlicenseBqualityCmaintenanceA Model Context Protocol (MCP) server that gives AI assistants full visibility and control over Kubernetes clusters.73MIT
- AlicenseNot gradedqualityCmaintenanceMCP server that connects LLMs to Kubernetes clusters for troubleshooting, scanning failing pods, diagnosing root causes, and applying guarded fixes or generating manifests via natural language.32 PyPIMIT