rocketplaneIO

Quick start · Is it safe? · Under the hood

Alpha. The full loop works end-to-end today, developed against minikube. APIs and schemas still change without notice — don't point it at production yet.

Three things you don't get anywhere else

1 · An AI SRE with a safety catalog — not an AI with kubectl

The Copilot investigates on its own: eBPF traces, logs, PromQL metrics, the live service map and the full Kubernetes inventory (Services, Ingress, ConfigMaps, policies — everything). But it can only change the cluster through ~30 named, reversible action pipelines. No shell, no kubectl, no YAML it could hallucinate.

Every action is risk-graded — and you set the approval rule per level:

Risk is parameter-aware (scale replicas=3 is reversible; replicas=0 is destructive), scope is enforced server-side (a namespace-scoped session cannot touch nodes or other namespaces), and every level can be set to auto, click, confirm or off.

The model proposes. Deterministic pipelines execute, verify at pod level, and roll back. The LLM never touches the cluster directly.

Bring any Anthropic- or OpenAI-compatible model — including a fully local, air-gapped one. Your telemetry never leaves your infrastructure either way.

2 · Traces for services you never instrumented

One outbound-only agent plus an eBPF DaemonSet (OTel eBPF Instrumentation, née Grafana Beyla). HTTP/gRPC spans with cross-service context propagation — including compiled Go binaries — plus SQL, Redis and Kafka client spans. No SDKs, no sidecars, no code changes.

3 · Every change proves itself — or undoes itself

Actions aren't fire-and-forget kubectl calls. Each one is a pipeline — trigger → observe → verify — that only reports success when the cluster actually converged: old pods gone, new pods Ready, stable. Cancel, timeout or a failed verify triggers automatic rollback from a snapshot taken before the mutation.

Quick start

The whole platform runs from published images (ghcr.io). You need Docker and a Kubernetes cluster to point it at (minikube is fine).

1 — run the platform

curl -O https://raw.githubusercontent.com/olemeyer/rocketplaneIO/main/deploy/compose/docker-compose.prod.yml
curl -o .env https://raw.githubusercontent.com/olemeyer/rocketplaneIO/main/deploy/compose/.env.example
# set RP_SESSION_SECRET in .env (e.g. `openssl rand -hex 32`); defaults are fine for a local trial

docker compose --env-file .env -f docker-compose.prod.yml up -d

The UI comes up on http://localhost:4173, the control plane on :8090.

2 — connect your cluster

Open the UI, create the owner account, hit Connect cluster — it hands you one copy-paste command that installs the agent and the Beyla DaemonSet (a rendered kubectl apply, or Helm). When the service map draws your namespaces and spans appear under Traces, you're live — without touching a line of your code.

Local minikube note: your cluster reaches the control plane at http://host.minikube.internal:8090, not localhost — set RP_AGENT_CONTROLPLANE_URL to that in .env before connecting.

3 — turn on the Copilot

Open it from the top bar and connect any Anthropic- or OpenAI-compatible provider (including a local one). The key stays on your instance; requests go straight from your control plane to the provider you chose.

Images are tagged edge (tracks main) today; tagged releases and a platform Helm chart are the next milestone. Want a demo workload? A Python + Redis shop behind nginx — the one in every screenshot here — ships in deploy/dev/ (kubectl apply -f deploy/dev/shop-realistic.yaml -f deploy/dev/frontdoor.yaml).

Is it safe?

The section every platform team reads first:

• Outbound-only. The agent dials out over HTTPS; nothing connects into your cluster, nothing listens. Actions are claimed by the agent — never pushed in.
• Enumerated RBAC, two blocks (deploy/install.yaml): observe is read-only; act holds exactly the write verbs the action catalog needs. Delete the act block (or set rbac.actions=false in Helm) for a strictly observe-only agent. No wildcards, no cluster-admin.
• Secrets: the inventory shows names, types and key counts — never values. That restraint is enforced in agent code; if you'd rather enforce it with RBAC too, delete the one secrets rule and the agent degrades gracefully.
• The LLM is caged. It reads through the same authenticated APIs you use, and mutates only via the whitelisted, validated, risk-gated action catalog. Every proposal, approval and result lands in the audit trail.
• eBPF: Beyla runs as a privileged DaemonSet (kernel ≥ 5.8 with BTF). The capture layer is upstream OpenTelemetry tooling — rocketplaneIO is the investigation-and-action loop on top.
• Footprint (measured on single-node minikube under continuous synthetic load — indicative, not a production benchmark): the rocketplaneIO agent is one lightweight pod at ~2m CPU and ~10Mi memory, cluster-wide. Beyla is the real cost and scales with request volume — ~0.02 core idle, spiking to ~0.25 core under load, ~280Mi memory per node (bounded; its default limit is 512Mi). One agent for the cluster, one Beyla per node.

What else is in the box

<b