KubeBolt docs
ENES GitHub

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
  1. How it works
  2. 32 read tools
  3. 9 action proposals
  4. Supported providers
  5. Reading your cloud
  6. MCP server (read-only)
  7. Contextual “Ask Kobi”
  8. Conversations
  9. Conversation memory
  10. Scope guardrail
  11. Usage analytics

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

ToolWhat it does
get_cluster_overviewResource counts, CPU/memory, health score, events
list_resourcesList 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_detailFull detail of a specific resource
get_resource_yamlRaw 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_describekubectl-describe output for deep troubleshooting
get_pod_logsPod logs with container, tail, since and grep options
get_workload_podsPods owned by a workload controller
get_workload_historyRevision history for Deployments/StatefulSets/DaemonSets
get_workload_metricsCPU / 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_jobsJob children of a CronJob to investigate execution history
get_topologyFull cluster topology graph
get_insightsActive insights with severity
get_eventsEvents with filtering. Without permission on events it says so: seeing none does not mean there are none
search_resourcesSearch by name across 16 common resource types in the selected cluster; with no match there, in your other clusters
get_permissionsDetected RBAC permissions
list_clustersAll 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_docsProduct knowledge base (features, navigation, admin pages)
get_insight_episodesHistory of insights: episodes that resolved, expired or are still firing, how each ended and how often it came back
get_insight_episodeOne episode in full: its append-only timeline, who silenced what and when, and the typed evidence the rule recorded
get_operational_episodesBursts of insights that fired together, already classified by shared cause (node rotation, rollout, and so on)
get_recent_deploysDeployment rollouts of the last hours, newest first: which workload got a new ReplicaSet, when, with which image
get_runtime_eventsRuntime security events from Falco: a shell spawned in a container, a sensitive file read, an unexpected outbound connection
get_findingsSecurity posture: CVEs and misconfigurations from Trivy, policy violations from Kyverno, CIS controls
get_finding_detailOne finding re-read live from the scanner, with every package carrying a CVE and its fixed version
get_finding_workloadsFindings grouped by workload and ranked to work through: exposed secrets first, then by severity
get_right_sizingRight-sizing recommendations from the same deterministic engine the Capacity and Cost screens read
get_coverageWhat KubeBolt can see right now: how the cluster is connected, which agents report, which metric sources answer
query_metricsA PromQL query against KubeBolt’s metrics store, confined to your organization and the current cluster
get_external_connectionsWhat 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_skillLoads 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_summaryActive insights per cluster across the whole organization, worst first. The only tool that sees beyond the selected cluster
offer_cluster_switchOffers 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

ToolProposesOn
propose_restart_workloadA rolling restartDeployment, StatefulSet, DaemonSet
propose_scale_workloadA replica count (0 pauses it)Deployment, StatefulSet
propose_rollback_deploymentA rollback to an earlier revisionDeployment
propose_set_imageNew container imagesDeployment, StatefulSet, DaemonSet
propose_set_resourcesNew CPU/memory requests and limitsDeployment, StatefulSet, DaemonSet
propose_set_envEnv vars added, changed or removedDeployment, StatefulSet, DaemonSet
propose_patch_hpaNew minReplicas / maxReplicasHorizontalPodAutoscaler
propose_debug_podAn ephemeral debug containerPod
propose_delete_resourceA deletion — you type namespace/name to confirmAny 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:

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.

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

  1. Create an API key with MCP only (read-only tools) — see the next section — and copy its value; it is shown once.

  2. Point the host at your KubeBolt URL with the key as a bearer header. For hosts that read an mcpServers file (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.

  3. 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…TokenScopes
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 networkAPI 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/mcpAPI 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:

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 varDefaultPurpose
KUBEBOLT_AI_AUTO_COMPACTtrueMaster switch for auto-compaction
KUBEBOLT_AI_SESSION_BUDGET_TOKENScontext window of the modelTotal ceiling. Trigger fires at budget × threshold
KUBEBOLT_AI_AUTO_COMPACT_THRESHOLD0.80Fraction of the budget at which compact fires
KUBEBOLT_AI_COMPACT_MODELclaude-haiku-5-5 / gpt-4o-miniOverride 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_TURNS3Turns 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.