Kobi
Kobi Copilot
Kobi's assisted mode: talk to your cluster in natural language, with 32 read tools and 9 fix proposals that run only when you approve them. Press ⌘J.
On this page
Kobi Copilot is the assisted mode of Kobi, KubeBolt’s AI SRE: you ask, Kobi answers. It ships in every edition — in the open-source core you bring your own LLM key (see Enabling Kobi); on KubeBolt Cloud the AI is managed. For how it relates to Kobi Autopilot, see Meet Kobi.
Open it with the Kobi launcher at the bottom right or ⌘J (Ctrl+J on Linux and Windows).
How it works
The copilot sends your question to the configured LLM provider along with the definitions of 41 built-in tools — 32 that read and 9 that propose a change — plus the tools of any cloud connector you are allowed to use. The backend runs every tool call itself, through the same cluster connection the rest of KubeBolt uses — the LLM never talks to your cluster directly. Kobi analyzes the results and answers with data-backed findings and, where useful, kubectl commands. With tool-call cards on (the default), each call shows in the panel as a card you can expand.
Beyond diagnosis, Kobi can propose the fix: restart, scale, roll back, set image, and more. A proposal changes nothing by itself — it runs only when you click Execute, under your KubeBolt role, after a server-side dry-run preview, and every executed action is recorded in the audit trail. See Actions & Governance.
Kobi also answers when no cluster is connected: it still talks about Kubernetes and KubeBolt, and tells you there is no live cluster to inspect. On KubeBolt Cloud, a question past your plan’s limit on questions at once waits in line instead of failing (see When Kobi is busy).
What reaches the model
Your messages, Kobi’s instructions, the tool definitions and the results of the tools Kobi calls: resource summaries and specs, events, log excerpts, metrics. Before a result leaves the backend, Secret data and values that look like credentials — in env vars, args, annotations, event messages, logs and describe output — are replaced with [REDACTED]. The request goes from the KubeBolt API to the provider endpoint configured in Enabling Kobi — on KubeBolt Cloud, the provider the platform runs; the browser never talks to the provider and never sees the key.
32 read tools
| Tool | What it does |
|---|---|
get_cluster_overview | Resource counts, CPU/memory, health score, events |
list_resources | List any of 33 resource types (workloads, networking, Gateway API, storage, config, RBAC, HPAs and VPAs, cert-manager Certificates, Argo CD Applications, Cilium policies, nodes, namespaces, events) with filtering |
get_resource_detail | Full detail of a specific resource |
get_resource_yaml | Raw YAML definition (secrets redacted, and an Argo CD Application’s Helm values, parameters and plugin environment hidden). Includes External Secrets objects (ExternalSecret, SecretStore, ClusterSecretStore), with a store’s inline credentials hidden. Lists each field manager’s last write; a manager name is what the write claims to be, not who made it |
get_resource_describe | kubectl-describe output for deep troubleshooting |
get_pod_logs | Pod logs with container, tail, since and grep options |
get_workload_pods | Pods owned by a workload controller |
get_workload_history | Revision history for Deployments/StatefulSets/DaemonSets |
get_workload_metrics | CPU / memory / network over a time range for a workload, pod, or node, and a node’s disk fill. CPU and memory points are each interval’s peak, and the answer says when the max happened |
get_cronjob_jobs | Job children of a CronJob to investigate execution history |
get_topology | Full cluster topology graph |
get_insights | Active insights with severity |
get_events | Events with filtering. Without permission on events it says so: seeing none does not mean there are none |
search_resources | Search by name across 16 common resource types in the selected cluster; with no match there, in your other clusters |
get_permissions | Detected RBAC permissions |
list_clusters | All available clusters, and whether each one’s agent is out of date, with the helm upgrade command to give you. Kobi never runs it |
get_kubebolt_docs | Product knowledge base (features, navigation, admin pages) |
get_insight_episodes | History of insights: episodes that resolved, expired or are still firing, how each ended and how often it came back |
get_insight_episode | One episode in full: its append-only timeline, who silenced what and when, and the typed evidence the rule recorded |
get_operational_episodes | Bursts of insights that fired together, already classified by shared cause (node rotation, rollout, and so on) |
get_recent_deploys | Deployment rollouts of the last hours, newest first: which workload got a new ReplicaSet, when, with which image |
get_runtime_events | Runtime security events from Falco: a shell spawned in a container, a sensitive file read, an unexpected outbound connection |
get_findings | Security posture: CVEs and misconfigurations from Trivy, policy violations from Kyverno, CIS controls |
get_finding_detail | One finding re-read live from the scanner, with every package carrying a CVE and its fixed version |
get_finding_workloads | Findings grouped by workload and ranked to work through: exposed secrets first, then by severity |
get_right_sizing | Right-sizing recommendations from the same deterministic engine the Capacity and Cost screens read |
get_coverage | What KubeBolt can see right now: how the cluster is connected, which agents report, which metric sources answer |
query_metrics | A PromQL query against KubeBolt’s metrics store, confined to your organization and the current cluster |
get_external_connections | What each address a workload calls is: inside the cluster, another of your clusters, a cloud service or outside. It reads Hubble flows, or the workload’s configuration when there is no Hubble, and follows an ExternalName Service to where it leaves the cluster |
load_skill | Loads one of KubeBolt’s 18 procedures, from a crash loop or a failing probe to an external dependency, a credential error or a rollback |
get_fleet_summary | Active insights per cluster across the whole organization, worst first. The only tool that sees beyond the selected cluster |
offer_cluster_switch | Offers a one-click switch to another cluster, carrying the question so the new conversation opens already asking it |
Node disk. For DiskPressure, ephemeral-storage evictions or “the disk
filled up”, Kobi reads the node’s disk with get_workload_metrics
(kind=Node, metric=filesystem): the fullest disk at each point, with
perMountpoint naming which one when node-exporter reports several mountpoints.
Each point is the peak of its step, so a disk that filled for a few minutes is
not averaged away, and the chat draws the result as a Disk card. Asking for
a pod’s or workload’s disk is refused rather than approximated — a pod’s disk
usage is not the node’s — and a metric that was not measured comes back with an
error instead of an empty series that would read as idle. Pod-level disk IO is
not exposed; PVC fill is read with query_metrics
(kubelet_volume_stats_used_bytes / kubelet_volume_stats_capacity_bytes).
9 action proposals
| Tool | Proposes | On |
|---|---|---|
propose_restart_workload | A rolling restart | Deployment, StatefulSet, DaemonSet |
propose_scale_workload | A replica count (0 pauses it) | Deployment, StatefulSet |
propose_rollback_deployment | A rollback to an earlier revision | Deployment |
propose_set_image | New container images | Deployment, StatefulSet, DaemonSet |
propose_set_resources | New CPU/memory requests and limits | Deployment, StatefulSet, DaemonSet |
propose_set_env | Env vars added, changed or removed | Deployment, StatefulSet, DaemonSet |
propose_patch_hpa | New minReplicas / maxReplicas | HorizontalPodAutoscaler |
propose_debug_pod | An ephemeral debug container | Pod |
propose_delete_resource | A deletion — you type namespace/name to confirm | Any resource |
Each renders an action card in the chat with a risk badge and an automatic dry-run preview: the cluster says whether it would accept the change — quota, LimitRange and admission webhooks included — before you click Execute. Nothing happens until you do, and it runs with your role: delete needs Admin, the rest Editor. After it runs, the panel follows the rollout; if it hasn’t converged within the action timeout (90 s by default), Kobi is asked why.
Admins can withhold all of them (KUBEBOLT_AI_ACTIONS_ENABLED=false) or only
the destructive ones (KUBEBOLT_AI_DESTRUCTIVE_ACTIONS_ENABLED=false). Details
in Actions & Governance.
Supported providers
KubeBolt ships two provider adapters, and KUBEBOLT_AI_PROVIDER accepts only these two values:
anthropic— the Claude API. The default model isclaude-haiku-5-5(Claude Haiku 5.5); Sonnet 5.5, Opus 5.5, Fable 5 and earlier Claude models are in the Configuration page’s catalog. Prompt caching covers the system prompt and tool definitions, kept for an hour by default.openai— OpenAI itself (default modelgpt-4o) and any OpenAI-compatible Chat Completions API: Azure OpenAI, xAI, DeepSeek, Groq, Mistral, OpenRouter, and self-hosted runners such as Ollama or vLLM. OpenAI’s Pro models are not supported: OpenAI serves them only through/v1/responses.
For anything other than OpenAI itself, set the base URL to the provider’s full chat-completions endpoint (for example https://api.x.ai/v1/chat/completions). KubeBolt posts to it as-is and never appends a path. The model must support tool calling. The Configuration page lists a curated catalog per provider and a Custom option for any other model ID.
The small default model answers most questions inside one cluster. Pair it with an escalation model so an investigation that leaves the cluster continues on a stronger one. Base URLs, keys and every setting are in Enabling Kobi.
Bring your own key. In the open-source edition you configure your own provider key and pay that provider directly; KubeBolt has no AI billing. The backend proxies every LLM request, so the key never reaches the browser, and a key saved from the UI is encrypted at rest. On KubeBolt Cloud the AI is managed — there are no keys to configure, and usage draws from your plan credits.
Reading your cloud
When the cause is outside the cluster, Kobi can follow it into your AWS or Azure account through cloud connectors, read-only. Connector tools are added to the ones above when an administrator sets one up and your role clears the connector’s minimum; if it doesn’t, Kobi tells you the connector exists and which role it needs. A call held back by the per-minute budget, or refused before it was sent, says so on its card instead of reading as a failure.
MCP server (read-only)
Thirty-one of the read tools are also exposed over the Model Context Protocol, so any MCP host — Claude Code, Cursor, a CI step, another agent — can investigate a live cluster using its own LLM. No KubeBolt AI key is needed: the host’s model does the reasoning, KubeBolt only serves the tools.
- Remote, over HTTP — the server publishes
POST /api/v1/mcpusing the standard Streamable HTTP transport, behind normal KubeBolt authentication with an API token. The token identifies the tenant; sendX-KubeBolt-Cluster: <context-name>(a name fromGET /api/v1/clusters) to target a specific cluster instead of the active one. - Local, over stdio — the standalone
kubebolt-mcpbinary speaks MCP over stdin/stdout against your kubeconfig directly, with no server and no auth. Download it from the GitHub release assets (kubebolt-mcp-linux-amd64,-linux-arm64,-darwin-amd64,-darwin-arm64,-windows-amd64.exe), rename it tokubebolt-mcpand put it on yourPATH, or build it withmake build-mcp.
Read-only is enforced server-side: the 9 propose_* tools are neither listed
nor callable, even by name — a call to one is a protocol error. The
thirty-second read tool, offer_cluster_switch, is withheld too: it draws a
card only Kobi’s own panel knows how to render, so to any other host it would
be a tool that does nothing. Cloud connector tools are never served over MCP.
The server also offers one MCP prompt, kobi-guidance, with Kobi’s operating
guidance for the host’s model.
Connecting a host
-
Create an API key with MCP only (read-only tools) — see the next section — and copy its value; it is shown once.
-
Point the host at your KubeBolt URL with the key as a bearer header. For hosts that read an
mcpServersfile (Claude Code, Cursor):{ "mcpServers": { "kubebolt": { "type": "http", "url": "https://kubebolt.example.com/api/v1/mcp", "headers": { "Authorization": "Bearer kbk_xxxxxxxxxxxxxxxx" } } } }Or, in Claude Code:
claude mcp add --transport http kubebolt https://kubebolt.example.com/api/v1/mcp \ --header "Authorization: Bearer kbk_xxxxxxxxxxxxxxxx"On KubeBolt Cloud the URL is
https://api.kubebolt.io/api/v1/mcp, with a key created in your organization. -
Ask the host something that needs live data (“using the kubebolt tools, are any pods crash-looping?”) and check that it calls the tools.
For the local binary, any host that launches a command works, Claude Desktop included:
{
"mcpServers": {
"kubebolt": {
"command": "kubebolt-mcp",
"args": ["--kubeconfig", "/home/me/.kube/config"]
}
}
}
kubebolt-mcp also takes --connect-wait (seconds to wait for the cluster
before serving, default 10) and logs to stderr, so the protocol stream on
stdout stays clean.
Which token to use
| Your MCP host reaches KubeBolt through… | Token | Scopes |
|---|---|---|
| The UI URL of a Helm or Docker Compose install (the bundled nginx — the usual case) | API key (kbk_) | Must include /api/v1/mcp or * |
The API directly — the single-container image, or the chart’s <release>-api Service from inside your network | API key or service token (kbs_) | A kbs_ token’s default scopes already include /api/v1/mcp |
KubeBolt Cloud, at https://api.kubebolt.io/api/v1/mcp | API key (kbk_) | MCP only; Cloud organizations don’t issue kbs_ tokens |
An API key has no default scopes. Pick MCP only (read-only tools) in
the create dialog: the key reaches /api/v1/mcp and nothing else, its role is
pinned to viewer on the server, and it expires in 90 days unless you change
it. Tick the clusters it may read in the same dialog, or leave the list empty
for every cluster. Through the API it is the same thing with
"scopes":["/api/v1/mcp"].
Service tokens don’t work through the UI URL. The bundled nginx marks
every request it proxies with X-KubeBolt-Edge: public, and the API rejects
kbs_ service tokens on those requests with 401 invalid or expired token.
That is deliberate: a leaked service token is useless from the internet. If
you want a kbs_ token, point the host at the API directly (for example
http://<release>-api.<namespace>.svc:8080/api/v1/mcp, or a
kubectl port-forward svc/<release>-api 8080:8080).
initialize and tools/list answer even while the cluster is momentarily
disconnected; a tools/call in that window returns an isError result that
says live cluster access is needed, instead of failing the session.
get_kubebolt_docs keeps working, since it needs no cluster.
Contextual “Ask Kobi”
One-click Ask Kobi buttons open the panel with a prompt already loaded with the cluster, namespace, resource and symptom. Surfaces include:
- Insight cards — diagnose the insight and recommend a fix
- Resource detail header — investigate the resource; the prompt adapts to the active tab (Monitor, Logs, YAML…)
- Workload health on the Overview — why a workload is not ready
- Warning events — explain the event and its impact
- Traffic flows on the Cluster Map — explain the flow, drops and error rates
- Dashboard panels — top CPU consumers, right-sizing, recent deploys, error hot-spots, top latency, network drops and more, for the whole panel or a single row
- Stalled actions — when an approved action doesn’t converge, Kobi is asked why
Conversations
Conversations are personal and persist per user, so you can refresh, sign out and resume where you left off. The History button in the panel header lists your past conversations; New conversation starts a fresh one. Persistence needs authentication enabled (the default). Retention and the per-user cap are set by KUBEBOLT_COPILOT_CONVERSATION_RETENTION_HORIZON (default 2160h) and KUBEBOLT_COPILOT_CONVERSATION_MAX_PER_USER (default 200).
Conversation memory
Long sessions stop bleeding context. When the estimated conversation size crosses SESSION_BUDGET_TOKENS × AUTO_COMPACT_THRESHOLD (default 80%), the handler folds older turns into a summary generated by the provider’s cheap-tier model (claude-haiku-5-5 / gpt-4o-mini) and stubs bulky tool_results in the preserved tail. The active turn’s tool_results are always protected so mid-flight compacts never truncate a response.
A Scissors icon in the panel header exposes the same primitive on demand — “new session with summary” collapses the whole transcript into a single summary message so you can pivot topics without losing context.
| Env var | Default | Purpose |
|---|---|---|
KUBEBOLT_AI_AUTO_COMPACT | true | Master switch for auto-compaction |
KUBEBOLT_AI_SESSION_BUDGET_TOKENS | context window of the model | Total ceiling. Trigger fires at budget × threshold |
KUBEBOLT_AI_AUTO_COMPACT_THRESHOLD | 0.80 | Fraction of the budget at which compact fires |
KUBEBOLT_AI_COMPACT_MODEL | claude-haiku-5-5 / gpt-4o-mini | Override the summarisation model — required on any OpenAI-compatible endpoint other than OpenAI itself, since gpt-4o-mini only exists there. It runs on the primary’s provider and key |
KUBEBOLT_AI_COMPACT_PRESERVE_TURNS | 3 | Turns kept intact after compaction |
The same settings are on Administration → AI (Kobi) → Configuration under
Behavior (Auto-compact, Session budget, Compact threshold, Compact model,
Preserve turns). The chart has no values for these variables: set them with
extraEnv, or from that page. On KubeBolt Cloud they are managed for your plan.
Scope guardrail
The system prompt defines in-scope (Kubernetes operations, DevOps/SRE topics that support the user’s cluster, KubeBolt itself) and out-of-scope (general coding unrelated to Kubernetes, non-technical topics, cloud products not running on Kubernetes). The LLM refuses out-of-scope questions with a one-sentence polite redirect in the user’s language — never answers partially.
Usage analytics
Administration → AI (Kobi) → Usage (Admin role): sessions, tokens billed, cache hit rate, estimated USD cost (a best-effort price table — your real bill is whatever your provider charges; unknown models show no estimate), top tools with error rates, and a per-session drill-down with tool breakdown and compaction events. Range selector 24h / 7d / 30d. Stored locally in BoltDB with a 30-day / 5,000-record retention cap. Requires authentication to be enabled. The Health tab next to it shows how answers end (completed, out of rounds, errors), the 👍/👎 feedback on answers and the cache read ratio; cloud calls that were refused or held back are not counted as failing tools.
On KubeBolt Cloud the same view is Administration → AI & Autopilot → Usage & Credits, in credits instead of dollars, with Copilot and Autopilot side by side.