kalpai's promise is simple: take a project from local dev to production and keep every signal — observability, CI, deploys — in one console. Under the hood, that console rests on two small command-line tools built with the same rule: nothing invented, everything assembled from what already works.

sklp — the developer CLI

sklp is the entry point. It orchestrates the local dev stack, runs CI/CD pipelines, manages ephemeral spaces, builds images and deploys — and watches the whole thing.

  • sklp dev / sklp run — local dev environment and pipelines from .sklp/ YAML files
  • sklp space — ephemeral, closed environments from .sklp/space.yaml
  • sklp deploy / sklp image — pilot a node, build OCI images daemonless
  • sklp logs, sklp issue, sklp flag — logs, issues and feature flags from the terminal
  • sklp macos manages the Linux VM it runs on under macOS (Virtualization.framework)

One command, machine-readable, built to be usable by both an operator and an AI agent.

skt — the rootless toolchain manager

Before any of that runs, you need the right binaries on the machine. That's skt: a standalone, rootless version manager. Give it <tool>@<version> and a target platform, and it returns the binary path as JSON.

skt resolve go@1.25.5 --json skt install go@1.25.5 --json

It replaces the mise fallback we used in sklp. Four steps, nothing more:

  1. Resolve — map <tool>@<version> to a release for the host OS/arch
  2. Download — fetch the artifact from the recipe's URL
  3. Verify — stream a sha256, compare constant-time to the published checksum
  4. Cache — extract into $XDG_CACHE_HOME/skt; warm hits skip the network

Recipes, not code

Every supported tool is a declarative TOML recipe — 15 bundled (air, bun, dive, gdu, gitleaks, golangci-lint, helm, jq, just, kubectl, nuclei, opentofu, task, trivy, wasm-bindgen). Each declares per-platform artifacts and a checksum strategy. Adding a tool is adding a recipe, not writing fetching logic.

Why it holds

Rootless, cached, verified, machine-readable. The toolchain manager thinks the way a CI system does: deterministic resolution, checksum-checked downloads, content cache. sklp orchestrates the what-to-run, skt the with-what.

What's next

The cache is the last step before the release.