kprompt.ai

Experimental·Review every plan before apply

Talk to Your Cluster.

Natural language becomes a reviewable plan — then you approve before anything touches Kubernetes. Early software: prefer non-production clusters until you trust the workflow.

Get StartedDocsGitHub
kprompt — natural language

›

Built for real cluster work.

What ships today in the MIT CLI — not a wishlist.

Natural language

Ask for deploys, rollbacks, scales, logs, and deletes in plain English — same kubeconfig as kubectl.

Plan before apply

Intent becomes a concrete execution plan with live before/after diffs when the resource already exists.

Safety + approval

Risk evaluation and hard denies for wipe-class prompts. Mutating plans need TTY y/N or --approve.

Day-2 intelligence

Explain-lite from status and events, log tails, compact describe, and OOM → suggested memory patches.

History + CI JSON

Local prompt history with rerun. --output json emits a stable PlanResult for pipeline gates.

BYOK models

OpenAI, Anthropic, Gemini, Groq, Ollama, and more. Keys stay in env vars — never in config.yaml.

How it works

Prompt in. Plan out. Apply with control — on your laptop, against your kubeconfig.

01

Prompt

Describe the cluster change or query in plain English.

02

Plan

LLM maps intent to concrete actions; live diffs when possible.

03

Safety

Risk level and hard denies (wipes, namespace deletes) run first.

04

Apply

You approve on a TTY (or --approve). Optional --wait for rollouts.

CLI that speaks Kubernetes.

One binary. Natural language in. Cluster actions out.

terminal

› kprompt "deploy redis"

Planning deployment…

✓ Deployment/redis planned

✓ Service/redis planned

Risk: medium — awaiting approval

On the horizon

One natural-language layer for your stack

kprompt is not here to replace Helm, Argo, or Prometheus — it orchestrates them through their real APIs and CLIs. You describe the outcome; we show the plan, then you approve. Nothing below is shipped yet.

kprompt

NL · plan · safety · approve

HelmArgoPrometheusOpenTelemetryGrafana

↓ Kubernetes API (client-go) ↓

Next

Helm & deeper Kubernetes

Helm

Planned

Chart install and upgrade via helm CLI — shown in the plan before exec.

kprompt "install redis"

Kubernetes depth

Planned

Chain Deployment → ReplicaSet → Pods → Events → Logs in one explain.

kprompt "why isn't my deployment ready?"

Later

Workflows & metrics

Argo Workflows

Planned

Generate and submit Workflows from a prompt — ML pipelines, batch jobs.

kprompt "train a yolov11 model"

Prometheus

Planned

Query metrics for performance explains — CPU, latency, HPA.

kprompt "why is my api slow?"

Later

Traces & dashboards

OpenTelemetry

Planned

Walk distributed traces and call out slow spans.

kprompt "trace payment request"

Grafana

Planned

Open or summarize dashboards from the terminal.

kprompt "show dashboard"

Exploring

Cloud-native ecosystem

GitOps

Planned

Flux CD / Argo CD sync status, promote, rollback.

kprompt "rollback yesterday's deployment"

Tekton · KEDA · Istio

Planned

CI pipelines, event-driven scale, traffic management — via real CRDs/APIs.

kprompt "create a CI pipeline"

Crossplane

Planned

Cloud resource claims with strong approval gates.

kprompt "provision a postgres database"

North-star prompts

The end state: you stop thinking about which tool to open.

  • kprompt "deploy my app"
  • kprompt "why is production slow"
  • kprompt "optimize my cluster"
  • kprompt "show service dependency graph"

From zero to first prompt

Install, save defaults with kprompt config, set an API key, then prompt. Keys never go in the config file — only whether they are set or unset.

  1. 01 · install

    Install the CLI

    Downloads the latest release binary into ~/.local/bin (no sudo on macOS).

    If the installer says PATH is missing ~/.local/bin, run the export in the next step.

  2. 02 · path

    Put kprompt on your PATH

    Make the binary available in new terminal sessions.

    You should see a version like 0.2.0.

  3. 03 · config

    Save defaults with kprompt config

    Persist provider, model, and namespace in ~/.kprompt/config.yaml. API keys are never written to that file — config only shows whether a key is set or unset.

    Config file: ~/.kprompt/config.yaml
provider:    gemini
model:       gemini-2.0-flash
base_url:    -
namespace:   default
context:     (default kube context)
api_key:     unset  (env: KPROMPT_GEMINI_API_KEY | …)
Secrets are never stored in the config file.

    Allowed keys: provider, model, base_url, context, namespace. Example view after set: provider gemini, api_key unset (until you export KPROMPT_GEMINI_API_KEY).

  4. 04 · api-key

    Set an LLM API key

    kprompt needs a model to turn your sentence into a plan. Without a key you get a missing API key error for your chosen provider.

    Also: OPENAI, ANTHROPIC, GROQ, MISTRAL, DEEPSEEK, OPENROUTER, TOGETHER — or ollama with no key. Full table in Docs → Providers. Never put secrets in config.yaml.

  5. 05 · kube

    Connect your cluster

    Uses your existing kubeconfig (same as kubectl).

    Optional: kprompt config set context kind-kprompt-e2e — or pass --context / -n on each command. Namespace phrases like in staging are parsed from the prompt when flags are omitted.

  6. 06 · prompt

    Run your first prompts

    Reads run immediately. Mutations show a plan (with live diffs when available), then ask y/N on a TTY — or use --approve. Add --wait after apply to block until the Deployment is ready.

    A greeting like kprompt "hello" is not a cluster op — use a real Kubernetes ask after the key is set.

  7. 07 · history

    Replay from history

    Recent prompts and plan summaries are stored locally (never manifests or API keys).

    File: ~/.kprompt/history.jsonl. Disable with KPROMPT_DISABLE_HISTORY=1 if needed.

  8. 08 · ci

    Gate plans in CI

    Emit a stable PlanResult JSON document for pipelines. Human UI goes to stderr; stdout is one JSON object.

    See Docs → CI for schema fields and jq helpers.

Common errors

missing API key for …
Export the env var for your provider (KPROMPT_OPENAI_API_KEY, KPROMPT_ANTHROPIC_API_KEY, KPROMPT_GEMINI_API_KEY, KPROMPT_GROQ_API_KEY, …) and pass --provider …. Restart the terminal after editing ~/.zshrc.
command not found: kprompt
Add ~/.local/bin to your PATH (see step 02).
kubeconfig / context / RBAC errors
kprompt rewrites common client-go failures into one-liners: missing ~/.kube/config, unknown --context, Unauthorized, Forbidden (with kubectl auth can-i … hints), and unreachable API. Confirm kubectl get ns works with your current context first.

Deep dive: Docs · GitHub

Why kprompt

Less ceremony. More reviewable cluster control.

Traditional Kubernetes

  • Hand-write YAML for routine changes
  • Memorize kubectl flags under pressure
  • Guess risk from a long diff alone
  • No shared trail of who applied what locally

kprompt

  • Describe the change; get a concrete plan
  • Review diffs and risk before apply
  • Hard denies for wipe-class prompts
  • History + JSON PlanResult for CI gates

Looking ahead

The CLI stays open source and free — and still experimental. Tool integrations above are planned, not shipped. We're also exploring a Team layer for org policy and audit. Nothing to buy today.

Now

Shipped

  • Open-source CLI (MIT)
  • Plan → safety → approve → apply
  • Deploy, scale, rollback, named delete
  • Explain, logs, describe, get/list
  • Prompt history and JSON plan output (CI)
  • Your LLM keys (BYOK)
  • Brand domain (kprompt.ai)

Next

Building

  • Homebrew install
  • Helm orchestration (install / upgrade)
  • Deeper Kubernetes investigation chain

Later

Exploring

  • Argo Workflows · Prometheus · OpenTelemetry · Grafana
  • GitOps (Flux / Argo CD) · Tekton · KEDA · Istio
  • Team: org policy sync · audit · shared identity
Shape priorities on GitHub

OSS CLI today · team policy & audit on the horizon.

Open source by design

Star the repo. Read the docs. Shape the roadmap.

Star us on GitHubRead the docs

MIT · Open source · Contributions welcome

Ready to talk to your cluster?

Install, run kprompt config, set an API key, then prompt your cluster. Experimental — review every plan; prefer non-production first.

  1. 01Install the CLI
  2. 02Configure defaults
  3. 03Set an LLM API key
  4. 04Prompt your cluster
View on GitHubRead the docsUsage guide