srelens MCP
A Rust Kubernetes workspace: desktop app, terminal UI and an MCP server that lets an agent work with your clusters
- 203 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- The agent works with the rights of the kubeconfig context and through mutating tools can scale, restart and delete resources and drain nodes
- The `--mcp-allow-sensitive-reads` and `--mcp-allow-destructive` flags open Secret reads and changes without a confirmation dialog
Install
- Works in
Manual install
brew install srelens/tap/srectlThe `srectl` terminal UI on macOS via Homebrew. The desktop window installs from the `.dmg`, `.AppImage`, `.deb`, `.rpm`, `.exe` and `.msi` packages on GitHub Releases.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- The agent works with the rights of the kubeconfig context and through mutating tools can scale, restart and delete resources and drain nodes
- The `--mcp-allow-sensitive-reads` and `--mcp-allow-destructive` flags open Secret reads and changes without a confirmation dialog
This is third-party code. Review the repository files before installing.
What it does
srelens opens the clusters from your local kubeconfig in three forms: a Tauri desktop window, a k9s-style terminal UI called `srectl`, and an MCP server. One Rust core drives all three, so an agent gets the same operations as a person in the window: browsing resources, events and YAML, logs, port forwarding, Helm, scaling, restarts, cordon and drain of nodes. The MCP server is generated from the same capability registry as the app backend. It starts with `srelens --mcp-stdio` or `srectl mcp`, and there is a loopback HTTP variant protected by a token. Destructive tools sit behind confirmation: the app shows a dialog, while a headless run needs the `--mcp-allow-destructive` flag and `"_confirm": true` in the call itself. Reading Secrets is enabled by a separate `--mcp-allow-sensitive-reads` flag. srelens talks to the clusters directly with the credentials from your local kubeconfig, and nothing goes through a project cloud.
Who it is for. SREs and platform engineers who investigate Kubernetes incidents and want to hand part of the investigation to an agent with the same rights their kubeconfig gives them.
Good fit when
- A pod keeps crashing under load and the agent has to read events, previous-instance logs and the manifest without you pasting `kubectl` output into chat
- You work across several clusters and want contexts from different kubeconfig files side by side under clear names
- You are on a jump host over SSH and need a k9s-level terminal UI with the same MCP server at hand
- Before a Helm rollback the agent should show the diff between revisions and change nothing until you confirm
Not a fit when
- You only need a narrow `kubectl` MCP server without a window or TUI: in srelens it is one of three faces of a single app
- The cluster is critical and the kubeconfig RBAC is broad: the agent inherits all of it, so create a read-only role first
- You need a signed installer on Windows: the README lists code signing as planned and a SmartScreen prompt may appear
- A one-off look at pods is enough: `kubectl get pods` works without installing an app
Example request
Use srelens to find out why the payments-api pod in the prod cluster keeps restarting: events, previous-instance logs and memory limits. Change nothing.MCP
- Transport
- stdio, http
- Authentication
- not required
Limitations
The agent acts with the rights of the context in your kubeconfig: srelens does not narrow them, and confirmation protects only the tools marked destructive. A headless `srelens --mcp-http` with `--mcp-allow-destructive` and `"_confirm": true` makes changes with no human involved, and `--mcp-expose-http` serves plain HTTP without TLS.
On Windows the installer is not yet code-signed, so the system may show a SmartScreen prompt. The old classic window design is marked deprecated. CPU and memory metrics work when the cluster runs `metrics-server`.
How to disable. Remove the `srelens` block from the MCP client config and stop the server: the toggle is in the MCP section of Settings in the app, where the token can also be revoked. The app itself is removed like any program, with per-platform steps in the repository's `docs/INSTALL.md`.
FAQ
How do I connect srelens to Claude Code?
Install the app or `srectl`, then add an MCP block named `srelens` with the command `srelens` and the argument `--mcp-stdio`. No token is needed for stdio because the client starts the process itself. The app copies a ready config snippet from the MCP section of Settings.
Can the agent delete resources or read a Secret?
Only with separate permission. Destructive tools ask for confirmation, reading Secrets is enabled with `--mcp-allow-sensitive-reads`, and changes without a window with `--mcp-allow-destructive`. The two flags are independent: permission to read a Secret does not allow draining a node.
How is srelens different from k9s?
k9s stays a terminal UI. srelens has the same idea as `srectl` and adds a desktop window and an MCP server on a shared core, so the agent and the person work with one set of operations.
Does cluster data go through a project cloud?
No. According to the README, srelens connects to the API servers directly with the credentials from your local kubeconfig, and no srelens cloud service sits in the chain.
Which operating systems are supported?
The window runs on macOS, Linux and Windows, and the `srectl` terminal UI is built for Linux and macOS on x86-64 and arm64, plus Windows on x86-64. There is also a Docker web mode with OIDC sign-in.
Discussion
No questions or reviews yet.
Related
MCP serversAn open-source Kubernetes UI with a built-in MCP server: the agent inspects the cluster, diagnoses breakages and operates it with RBAC in mind
MCP server for Kubernetes: the agent reads cluster state, diagnoses pod failures and runs operations through kubectl
An MCP server and skills on top of Kubernetes network observability: an agent investigates incidents and queries cluster traffic through an eBPF-built index
CISRE’s MCP server gives an agent Kubernetes diagnostics and resource operations with a configurable namespace boundary.
An MCP server in Go: an agent reads pods, logs and events of a Kubernetes cluster, changes resources and runs commands in pods
A Rust code-quality sensor that scores a project before and after an agent session, installable as a Claude Code plugin or MCP server
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| srelens (this card) | yes | not required | 203 | |
| K9s | no | 34,934 | a terminal UI without a desktop window or a built-in MCP server | |
| Kubernetes MCP Server | no | not required | 2,228 | an MCP server in Go only, without a window or terminal UI |
README in short
The README presents srelens as a local workspace for SREs: window, terminal and MCP on one core. It details the MCP launch modes, the confirmation design, a Docker web mode with OIDC sign-in and a package table per platform. Installer size is compared with Freelens: 17.1 MiB on macOS against 190.2 MiB.