Applications: your software, not a pile of replicasets
Radar now folds related workloads into the applications they actually form, using Helm, Argo, Flux, label and naming evidence - so the first thing you see is your software, not the objects it decomposes into.
App rows resolved from workload, GitOps, Helm and label evidence, each with its own health rollup, class (Service / Worker / Job) and app-vs-add-on classification
Instances of the same app across dev, staging and prod fold into a single row, with a skew badge when one environment falls behind another
Filter by availability, class, type, environment or grouping source; open any app for its own seeded topology and related-object YAML explorer
Open-source Radar gets a ground-up navigation and search overhaul: a left nav rail that holds every view, list surfaces rebuilt on shared primitives, and a global omnibar that searches the whole cluster, not just the current view.
Left nav rail with every view (Applications included) - pin it open or collapse to an icon rail, with g-mnemonic shortcuts
Omnibar advanced search across the whole cluster: kind:/ns:/label:/image:/cluster: filter pills, autocomplete, ranked results, and recents
Issues, Checks, Applications, and GitOps rebuilt on shared list primitives - one filter rail, one badge grammar, consistent column sorting
Themed hover tooltips in place of the browser's default ones, and per-page browser tab titles make multiple Radar tabs distinguishable
The Issues engine now collapses noise into causes: when one failure spawns many rows, Radar folds them into the single root-cause incident, and links causally-related problems across resources so you can see the blast radius.
Same-subject coalescing: a Deployment 'degraded' plus its crashlooping pods become one root-cause row, and a fold never lowers severity
Cross-subject causal links: a memory-pressured node or a broken PVC links to the pods it's taking down, with confidence labels (high / medium / low)
Live Operational Issues now appear in a resource's own detail view, not only in the cluster-wide queue
Exec and port-forward now work against modern clusters and gateways, and when a live forward can't work (in-cluster installs) you can still hit a Service's HTTP endpoint straight from the UI.
Exec, attach, cp, and port-forward moved to the WebSocket API with automatic SPDY fallback - so streaming works behind gateways like GKE Connect Gateway that block SPDY
Probe or Curl a Service's HTTP endpoint from inside the cluster (status, latency, headers, body) when port-forward isn't possible, plus a copy-paste kubectl port-forward command on every port
A Retry button on failed port-forwards re-resolves to a running pod in one click
A set of improvements that make genuine problems easier to spot and cut false signals: high-signal Cluster Audit findings now badge resources directly on the topology and in lists, restricted users get an actionable denied-state for cluster-scoped kinds they can't read, and a few benign lifecycle states that used to read as unhealthy now render neutral.
Per-resource badges flag genuinely broken resources (dangling refs, a Service with no endpoints, deprecated APIs) on the topology graph and resource list - curated to signal, not best-practice noise
Traefik reference-integrity checks catch routers, chains, and errors-services pointing at Services or Middlewares that don't exist, plus new Traefik detail renderers
Cluster-scoped resources your identity can't list now show a copy-paste RBAC request instead of a bare '0 / None found'
Suspended CronJobs, completed Jobs, and other intentional states render neutral rather than amber/red, so they don't crowd the Unhealthy filter
Building on Radar's MCP tooling, AI agents can now run read-only PromQL against your cluster's Prometheus - closing the loop from 'is this workload saturated?' to a concrete metric answer without leaving Radar.
query_prometheus for instant and range queries, all shaped for LLM consumption with oversized-result summarization
discover_metrics and get_prometheus_rules round out the read-only Prometheus toolset
Move between a cluster and the fleet without losing your place
Jumping from a single cluster's views to fleet-scoped pages is now a smooth, same-document hand-off - no full reload, and you land on the matching scoped view.
Same-document hand-off from a cluster's views (including GitOps detail) to the matching fleet-scoped page
Land on the home dashboard, with fleet-shaped cards routed to their scoped fleet tabs
A recent-clusters rail highlights the cluster you currently have open
Cloud
One Cloud shell across the fleet
Radar Cloud's chrome is now consistent from a single cluster to the whole fleet, with a global scope filter and one shared omnibar that searches across every connected cluster.
Consistent navigation and chrome whether you're scoped to one cluster or the whole fleet
A global scope filter to narrow any view to the clusters, environments, and namespaces you care about
One omnibar that searches across the fleet, labeling each result with the cluster it lives in
Cloud
Connect external AI agents over OAuth
Building on org-wide agent management, Radar Cloud now exposes an MCP endpoint that outside AI agents connect to over OAuth 2.1 - so you can grant a tool fleet access without minting and mailing around personal tokens.
MCP OAuth 2.1 with discovery, token validation, and just-in-time membership
A Connected Apps surface to see and revoke which agents have access
An org-wide read-only access mode for look-but-don't-touch agents
Continuing the Issues engine work, Radar's deterministic diagnostic signals get sharper and more actionable - with concrete cause and remediation text for the failures operators actually hit.
Pod issue banners now carry the underlying kubelet/status detail (evictions, image-pull errors, config errors, probe failures) alongside Radar's stable labels
Cause + action for crashloop exit codes, image-pull failures, and admission blockers (quota, webhooks, Pod Security); eventless post-bind startup stalls are caught even after kubelet events age out
HPA diagnosis as a first-class insight: maxed-out, can't-read-metrics, pinned, or paused autoscalers each get an explicit diagnosis
Change-feed correctness: lifecycle events are no longer pushed out by update churn, and a delete+recreate folds into one 'recreated with changes' entry
Turn the fleet Issues queue into alerts: write notification rules and hear about a break the moment it happens, in Slack or the in-app tray, with a durable history of everything that fired.
Notification rules with targeted delivery to the right people
Slack and in-app tray destinations
Durable alert history that deep-links back to the issue
Radar now sees GPUs and other extended resources end to end - on nodes, pods, and workloads - with first-class support for the NVIDIA GPU Operator and Kubernetes Dynamic Resource Allocation.
Extended-resource (GPU) capacity and requests surfaced on nodes, pods, and workloads
The Issues engine moves past pod-startup failures into the things that actually wake you up - GitOps sync failures, autoscaler problems, and stalled rollouts - each with a probable cause and the change that triggered it.
GitOps/ArgoCD sync failures diagnosed with cause and remediation
HPA and autoscaler problems surfaced as first-class issues
Detects pods that bind to a node and then silently stall with no events
Every issue carries its timing and the meaningful change that preceded it
Fleet Issues & Checks - one triage queue for the whole org
The Issues and Checks queues go org-wide in Radar Cloud: every cluster's failures and policy findings roll up into shared queues your whole team triages from, instead of each person re-discovering the same problem.
Org-shared triage - acknowledge, snooze, or dismiss an issue once for everyone
A Checks remediation queue with org-level Policy to mute a category or check
Grouped by subject, the same triage model as single-cluster Issues
A reworked Issues view built to answer one question: what's actually broken in this cluster right now. A classification engine groups failures by subject into a triage queue you can work straight through.
Pod-startup diagnostics plus coverage for runtime and platform failures
Kyverno policy violations and Checks findings feed the same list
Surfaced on the home dashboard so problems are the first thing you see
A global scope picker narrows every fleet view to the clusters you select, so a large org can focus on the handful that matter right now instead of scrolling past the rest.
One scope picker that filters the whole fleet, not each page separately
The command palette now indexes fleet resources inline, so ⌘K reaches across clusters
Prometheus rightsizing overlays and workload charts
The metrics view goes from raw graphs to actionable guidance - overlaying requests and limits against real usage and surfacing the charts you actually debug from.
Request/limit overlay with rightsizing suggestions
HPA, PVC, and restart charts
CPU/memory requests and capacity shown even when metrics-server is unavailable
Custom HTTP headers for auth-protected Prometheus backends
Pick two clusters and diff the same resource side by side as YAML - the fastest way to catch the staging-vs-prod drift behind 'but it works on the other cluster' bugs.
Side-by-side YAML diff for any resource across two clusters
Wired into fleet search, so you can jump from a match straight into compare mode
Cloud
Self-hosted Radar Cloud
Run the entire Radar Cloud control plane and dashboard inside your own infrastructure - the same fleet experience, with no dependency on our hosted service.
Self-hosted control plane and web app for air-gapped or compliance-bound teams
Runtime-configurable deployment shape with provided container images
Cloud
Org-wide agent management
Radar Cloud has spoken MCP since the early builds; this adds the governance layer on top - a dedicated Agents page that inventories every agent and token across the org, so you can see and control what AI has access to.
A dedicated Agents page, promoting MCP setup out of the Home screen
Org-wide inventory of personal access tokens with activity status
A persistent Write badge flags agents and tools that can mutate cluster state
Cloud
Cross-cluster GitOps in Radar Cloud
See every ArgoCD and Flux application across your fleet in one list, then drill into any of them with full visualization parity with single-cluster Radar.
Applications from every connected cluster in a single GitOps view
Destination correlation maps each app to the clusters it deploys to
The same actions and sync visualization you get inside one cluster
Two rounds of work aimed at the cluster sizes where Radar previously felt sluggish: a leaner cache (less memory, less bandwidth on every refresh) and a smarter first paint (no more flickering through three intermediate states before settling).
Cache trim: drop managedFields and CRD schemas from the dynamic cache, where they bloat memory without ever being read (v1.5.4, Apr 24)
First paint: ship a minimal-set frame and use a patience window to coalesce the initial loading flicker, so topology and resource lists settle into final state directly (v1.5.8, May 2)
A hosted overview that rolls up health from every connected cluster onto one screen, so the first thing you see is what needs attention - no opening each cluster to find out.
Problems, certificate inventory, checks, and package versions aggregated across all clusters
Fleet-wide search to locate any resource in any cluster
Logs viewer: timestamp formats, stack traces, field filter chips
Logs viewer gets a power-user pass. Choose absolute / relative / epoch timestamp formats, toggle ANSI and stack-trace folding, and filter on any structured field with one-click chips.
Radar OSS gains the plumbing it needs to run as part of Radar Cloud: a self-upgrade endpoint, version/namespace advertisement to the cloud handshake, embedded-mode chrome hides, and a settings strip + default RBAC bindings for cloud-managed installs.
Self-upgrade endpoint - in-cluster Radar can upgrade itself (Helm RBAC ported in v1.5.4)
Cloud-mode auth/RBAC, settings strip, and default RBAC bindings
Embedded-mode chrome hides for when Radar runs inside the hosted dashboard
Support for OIDC Back-Channel Logout - your IdP can now terminate Radar sessions server-to-server when a user signs out elsewhere. Plus cookie size safety fixes and an OIDC prefix option for installations sharing a domain with other apps.
Command-palette ranking gets retuned for the most-used kinds and actions, and ⌘K now works while focused inside text inputs (with soft suppression so you don't yank focus mid-typing).
Radar now understands Cluster API. Browse CAPI-managed clusters across AWS, GCP, and Azure, jump into any of them with a one-click kubeconfig download, and switch the topology view into Fleet mode to see every workload cluster on a single canvas.
AWS, GCP, and Azure CAPI provider renderers with provider-aware UI
Fleet topology mode for multi-cluster environments
Condition-based CAPI problem detection surfaced on the dashboard
Kubeconfig auto-connect and 'topology-controlled' badges on managed clusters
Generic 'render YAML for any kind' is fine until you actually need to debug a CNPG cluster or an Argo Workflow. This release ships dedicated renderers with the right fields, statuses, and problem detection per provider.
A built-in audit that scans your cluster against security and efficiency best practices and groups findings so you can fix them in batches instead of one resource at a time.
Grouped findings UI - see every Pod missing a resource limit in one row, not 200
Honors Kubernetes inheritance: a check on a Deployment doesn't double-fire on its Pods
Click through from any finding to the resource and the exact field to fix
Comprehensive rendering for Kubernetes NetworkPolicies (and Cilium policies) with a visual flow diagram so you can finally see what each policy actually permits, not just read the YAML.
Visual policy flow: ingress, egress, and the selectors that route them
Traffic correlation - cross-reference policies against live Hubble flows
You could already edit existing resources. Now you can create new ones (or paste a multi-document manifest) directly from the UI - with the same RBAC capability checks Radar runs on every other write.
OIDC integration improvements aimed at tighter enterprise environments - the kind that have a self-signed CA in front of the IdP and credentials you can't paste into a config file.
TLS skip-verify and custom CA cert flags for OIDC providers
Load OIDC client secret from an existing Kubernetes Secret
'Authenticate in terminal' button when the embedded browser flow can't complete
Service traffic view goes from L4 connection lines to full L7 request inspection. Latency, DNS lookups, HTTP status codes, request paths, and per-flow filters - reading from Cilium Hubble where it's available.
Per-request latency, DNS resolution times, HTTP status codes, and request paths
Flow list view with protocol filters
Dock integration for keeping the traffic graph open while navigating
Topology view now collapses cleanly through three levels - cluster, namespace, workload - with smart default collapse states so big namespaces don't blow up the canvas.
Radar now respects Kubernetes RBAC end-to-end. Sign in with your IdP, and every read, write, and exec runs as you - no more 'Radar can do anything its kubeconfig can do' shortcut.
OIDC sign-in with your existing identity provider
Per-user RBAC capability checks on every action
OIDC RP-Initiated Logout (v1.3.3) for IdP-initiated session end
Visual refresh: every color, spacing value, and elevation now flows from one design token set, which means consistent dark mode, fewer one-off components, and a cleaner base for everything we ship next.
Before you delete a Deployment, see every dependent resource that's coming with it. The delete dialog shows the full ownership chain so you don't accidentally take out a ServiceAccount you didn't mean to.
Structured log viewer + SSE-driven live resource lists
Logs viewer learns to parse JSON and logfmt natively, with field-level highlighting and an expand-all action. Resource list views switch to server-sent-events for instant invalidation - changes from another tab or kubectl reflect without manual refresh.
A local shell pinned to the active cluster context. kubectl, helm, whatever you have on your PATH - no tab-switching to your terminal, no copying cluster names.
First-class node operations from the cluster view. Cordon a problematic node, drain it for maintenance, uncordon when you're done - with the same RBAC checks as everything else.
View preferences, namespace filters, and cluster connections now persist across sessions. There's also a real Settings panel inside the app - no more hand-editing JSON.
Streaming progress for Helm upgrades and rollbacks
Helm upgrade and rollback operations now stream progress in real time instead of going dark for the duration. Watch hooks fire, resources reconcile, and status flip live - not as a wall of text after the fact.
Export any topology view as a high-resolution PNG or WebP - viewport capture or full canvas - to share in a Slack thread, paste into a doc, or attach to an incident review.
Quality-of-life pass on transitions, easing, and a stack of small papercuts that piled up during the v1.0 push. Drawer open/close, topology pan/zoom, and table-row state changes all feel meaningfully nicer.
A week after 1.0, three meaningful additions: cluster cost visibility via OpenCost, Istio service-mesh topology rendering, and an MCP server expansion that gives AI agents Helm, workload, and GitOps tools alongside the existing read-only resource browsing.
OpenCost cost view - per-namespace and per-workload spend, no extra dashboard
Istio service-mesh topology with mTLS and routing context
Post-1.0 dashboard expansion: HPA / CronJob detection, node health
Day-after-1.0 follow-up: dashboard now detects and surfaces HPA and CronJob state, adds node-health rollups, and converges the MCP and REST dashboard views so AI agents and the UI see the same shape of data.
After ~30 days of weekly OSS drops, Radar hits 1.0. The major surface area - topology, event timeline, traffic, resource browsing, Helm management - is stable and the v1.0 release adds a stack of features that earned the version bump.
Prometheus metrics integration with auto-discovery
PV, StorageClass, PDB, and VPA renderers
Comprehensive keyboard navigation across the app
Inline secret data editing with RBAC capability checks
Init Containers section in pod details, sortable/filterable CVE view
MCP server config so AI agents can introspect Radar's view of the cluster
Deeper rendering for the CRDs you actually use to run modern Kubernetes. Karpenter NodePools, KEDA ScaledObjects, and Gateway API resources get type-aware detail views instead of raw YAML dumps.
Radar exposes an MCP (Model Context Protocol) server so AI agents - Claude Code, Cursor, Continue, anything that speaks MCP - can query your cluster through Radar's typed view instead of shelling out to kubectl.
MCP server gives agents structured access to topology, events, logs, and resources
Pinnable favorites for resource kinds in the sidebar
Resizable columns, column picker, and persisted resource-table preferences
Container selection submenu on the Logs button for multi-container pods
Trivy Operator support and TLS certificate inspection
Two security-focused additions: first-class Trivy Operator rendering for VulnerabilityReports and ConfigAuditReports, plus inline parsing of TLS certificates stored in Kubernetes Secrets so you can see expiry, issuer, and SANs without copying them out.
Trivy Operator: dedicated renderers for vulnerability and config audit reports
TLS certificate info for K8s secrets - expiry, issuer, SANs surfaced inline
Generic column filter system for resource deep-links
Three big infrastructure pieces in one drop. Radar gets a native desktop app via Wails v2 (smaller binary, better OS integration than the Electron-style approach), graceful degradation when running with limited cluster permissions, and dynamic discovery of Prometheus or VictoriaMetrics endpoints.
Native desktop app built on Wails v2
Graceful RBAC degradation for limited-permission clusters - features disable cleanly instead of erroring
Dynamic Prometheus / VictoriaMetrics service discovery - no manual endpoint config
Multi-select namespace filter and OIDC kubeconfig auth
Filter the cluster view by any combination of namespaces, and connect to clusters whose kubeconfig uses OIDC (or other auth-provider plugins) without surgery.
Multi-select namespace filtering across topology, resources, and events
OIDC and other auth-provider support in kubeconfig parsing
Windows distribution: Scoop and PowerShell installer
First-class Windows install paths: a Scoop bucket for the CLI and a one-line PowerShell installer for users who don't want to add a package manager. macOS and Linux already had Homebrew, Krew, and a curl-able install script.
Browse the contents of any container image without pulling it locally - layer breakdown, file tree, file contents. Useful for spotting what's actually in a base image, debugging COPY ordering, or checking if a binary made it in.
Radar reads from your GitOps controller and shows what's actually deployed vs. what's declared. Plus a few related shipping items in the same window: workload-level log viewing and generic CRD topology via owner references.
ArgoCD and FluxCD application/source tracking
Workload-level log viewing (v0.7.5) - one log stream across all pods of a Deployment
Generic CRD topology via owner references (v0.7.7) - works for CRDs Radar has never seen
A single landing view that surfaces cluster health, recent events, and quick navigation - plus dedicated renderers and consistent iconography for every Kubernetes resource kind. Day-after follow-up (v0.6.4) added metrics charts and a metrics-history endpoint to the dashboard.
Helm chart deploy and service traffic visualization
Two foundational features: ship Radar into your cluster via a Helm chart, and see service-to-service traffic in the topology view (the precursor to the L7 Hubble integration that landed in March).
Helm chart for in-cluster deployment
First service traffic visualization on the topology canvas
Real write actions from the UI - delete, restart, trigger or suspend a CronJob - plus a unified event timeline that pulls from all sources into one chronological stream. Argo Rollouts is rendered properly too.
First public release. Apache 2.0 licensed, runs locally as a desktop app or kubectl plugin, talks to your cluster from your machine - no agents, no account, no telemetry.
Topology view with hierarchical grouping and filter sidebar
