Live-cluster benchmark · 25 injected faults

Which Kubernetes MCP server is fastest?

Radar, two general Kubernetes MCP servers, k8sgpt, and raw kubectl faced the same faults on the same cluster. Across all 25, Radar submitted a diagnosis in a median 38.0 seconds.

Explore the results See how it was run

38.0s

median first diagnosis

all 25 faults

38%

less time

than the next-fastest MCP arm

median tool calls

vs 14–18 for the other MCP arms

Median time to first submitted diagnosis

Bars include all 25 faults. Each line below shows the stricter check on the same 16 faults every arm diagnosed correctly. Lower is faster.

agent start → first submitted diagnosis

01Radarfastest
Correlated cluster model · 8 median calls
38.0s
same 16 correct faults36.0s · 6.2 calls
02Flux159/mcp-server-kubernetes
kubectl/Helm command tools · 14 median calls
61.5s
same 16 correct faults57.2s · 11 calls
03containers/kubernetes-mcp-server
Native Kubernetes API client · 14 median calls
64.3s
same 16 correct faults55.8s · 12.5 calls
04kubectl
Shell and kubectl · 8 median calls
72.4s
same 16 correct faults62.8s · 6 calls
05k8sgpt
Analyzer plus resource reads · 18 median calls
119.4s
same 16 correct faults91.0s · 12 calls

Speed is one part of the decision.

Compare all five servers on safety, writes, coverage, setup, multi-cluster reach, and governance.

See the full ranking

Why the gap

It’s not MCP vs CLI. Radar does the investigation before the agent asks.

Radar continuously connects workload state, events, logs, ownership, topology, and likely causes. The agent starts with that investigation work already done instead of reconstructing the cluster one call at a time.

The evidence is already connected

Radar maintains a live model of how workloads, events, changes, logs, ownership, and topology relate. The likely cause is connected to the affected resource before the first tool call.

Fewer serial calls

Radar needed 8 median tool calls across all faults. The other MCP arms needed 14 to 18. That is less model back-and-forth, not a faster wrapper around the same command.

The lead survives the stricter check

Radar leads across all 25 faults at 38.0s. Restrict the comparison to the same 16 faults every arm got right and Radar still leads at 36.0s. Quick misses do not explain the result.

Scenario explorer

Every fault. No aggregate hiding place.

Pick a failure and inspect the submitted time and judge score for all five tool surfaces.

Pick an injected fault

The same agent saw the same fault through each tool surface.

Astronomy Shop

Readiness probe misconfiguration

bar = timescore = judge

Radarcorrect
34.2s · score 1.00
containers/kubernetes-mcp-servercorrect
64.3s · score 1.00
Flux159/mcp-server-kubernetescorrect
91.7s · score 1.00
kubectlcorrect
328.3s · score 1.00
k8sgptcorrect
82.3s · score 1.00

Time runs from agent start to first submitted diagnosis. A correct badge is the harness verdict; the numeric score preserves partial credit. Download the JSON for every scenario-level measurement.

Methodology

A controlled tool-surface test

The model, fault, cluster, judge, and submission rule stay fixed. Only the way the agent reaches Kubernetes changes.

Agent

claude-sonnet-5

Cluster

3-node EKS, us-east-1

Judge

claude-opus-5, first submit

Benchmark

SREGym (Microsoft + UIUC)

Tool surfaceVersionBenchmark configuration

Radar MCP1.9.2Built-in MCP server; diagnosis task only

containers/kubernetes-mcp-serverv0.0.66--disable-destructive

Flux159/mcp-server-kubernetes4.1.2ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS=true

Raw kubectlEKS cluster clientDirect shell access

k8sgpt MCP0.4.36k8sgpt serve --mcp --mcp-http

Accuracy is not the differentiator here. Most arms scored highly and the gaps are too small for a confident ranking. The speed lead is much larger, and Radar keeps it across all 25 faults and on the shared 16-fault check.

Audit the numbers directly

25 scenarios, with every score, verdict, timing, and tool-call count in one JSON file.

Download JSON

Published August 9, 2026 · Last updated August 10, 2026. SREGym scenarios, configs, and public data verified on the date above.

Two benchmarks

One isolates the mechanism. One compares the field.

The two-way study goes deeper. The five-way study broadens the field.

This benchmark

Five tool surfaces, 25 faults

Which surface gets the same agent to the answer fastest? Radar leads across all 25 faults and on the 16-fault shared-correct check.

Original benchmark

Radar vs kubectl, 54 faults

A deeper two-arm replay isolating correlated MCP context against raw kubectl on the 44 faults both arms got right.

Open the replay

FAQ

Kubernetes MCP benchmark questions

What is the fastest Kubernetes MCP server?

Radar was fastest in this benchmark. Across all 25 faults, Radar submitted its first diagnosis in a median 38.0 seconds. The next-fastest MCP server took 61.5 seconds, and raw kubectl took 72.4 seconds. Radar also led the stricter 16-fault check where every arm was correct: 36.0 seconds versus 55.8 for the next MCP server.

Does this benchmark prove which Kubernetes MCP server is best?

It establishes a strong speed result for diagnosis, not a universal winner. Best also depends on safety controls, write support, resource coverage, installation, multi-cluster reach, governance, and how much cluster context the server returns. The companion comparison page evaluates those product dimensions separately.

How were the Kubernetes MCP servers compared fairly?

Every arm used the same claude-sonnet-5 agent, SREGym fault scenarios, 3-node EKS, us-east-1, and claude-opus-5 judge. Time runs from agent start to its first submitted diagnosis. The page shows all 25 faults, then repeats the comparison on the 16 faults every arm diagnosed correctly so quick misses cannot explain the result. Radar leads in both views.

Why show both all 25 faults and a 16-fault subset?

The all-fault median reflects the complete benchmark, including misses. The shared-correct median removes correctness as a confounding factor by comparing the exact same successfully diagnosed faults. Radar leads both: 38.0 seconds across all 25, and 36.0 seconds on the shared 16.

Which Kubernetes MCP server was most accurate?

This benchmark does not establish a meaningful accuracy winner. Most tools scored highly and the gaps are too small for a confident ranking. The public dataset includes every score; the clearer result here is diagnosis speed.

How does this differ from Radar's 54-fault MCP vs kubectl benchmark?

The 54-fault benchmark is a deeper two-way Radar-versus-kubectl study. Re-running all 54 faults across five entrants would be a substantially larger experiment; this comparison uses 25 faults because the speed result was already clear across the full sample and the 16 faults every arm got right. The samples are different, so compare each benchmark on its own rather than combining their medians.