$ ssh kai@kai-server

┌────────────────────────────────────┐
│ kai-server · lights-out            │
│ operator: kai siren · east bay, ca │
│ status: agents working the line    │
└────────────────────────────────────┘

⚙⚒ lights out, platform's green, agents are working the line ⚒⚙

Hi! I'm Kai. I'm a platform engineer, ten-plus years in. I build tools that make engineering teams faster. The current edge of that work is agentic developer tooling and observability designed for LLM consumers.

Outside work, I run a two-site homelab and a public game server. They are practical testbeds for the same platform, reliability, and observability questions I work on professionally.

/now is the living snapshot of what I'm building, testing, and thinking about.

The goal is unattended software work that stays bounded, inspectable, and recoverable. The current public stack covers four parts of that problem:

• ward - governed execution - runs unattended coding agents in fresh clones and least-access containers, with durable issue, branch, review, and outcome trails.
• cli-guard - execution boundary - validates arguments, scopes filesystem access, gates repository state, controls egress, and records an append-only audit log.
• agent-compose - context assembly - selects and compiles the instructions an agent starts with while keeping executable authority outside the bundle.
• agentic-os - shared operating layer - carries cross-platform shell setup, public-safe agent skills, and the cross-repo validation catalog.

The observability work sits underneath that stack: local-first session data, materialized views over agent behavior, and model-facing query surfaces. The useful question is not whether an agent produced a diff. It is whether the system can explain what happened, recover from interruption, and prove the result.

The work is split across four namespaces:

• coilyco-flight-deck - public builds - the governed agent stack, shared developer environment, and fleet infrastructure.
• coilyco-bridge - control surfaces - operator-specific context and deployment machinery.
• coilyco-gaming - games and game tooling - Eco services, Eco mods, Steam operations, and the galaxy generator.
• coilysiren - personal work - this profile and coilysiren.me.

The fleet has two small k3s clusters. The primary site is the application and state plane. The second site is the operations and recovery plane. This is the deployment-declaration view, grouped by namespace rather than pod count.

• coilysiren-backend - the personal API and its database.
• coilysiren-eco-* - the Eco companion stack, including the main service, Discord worker, and price calculator.
• atlas, factory-game, galaxy-gen, website - public and staging web surfaces.
• comfyui, open-webui, reference-media - private AI and media interfaces. ComfyUI keeps the GPU runtime on a tower and puts only its front door in k3s.
• forgejo-issues - the local issue mirror, synchronization workers, and query surfaces.
• *-mcp - narrowly scoped MCP services for node health, browsers, telemetry, project trackers, social sources, games, and infrastructure.

• authelia - OAuth 2.1 and OpenID Connect for hosted MCP clients. Per-service oauth2-proxy gates validate Authelia-signed access tokens.
• kube-system, cert-manager, external-dns - Traefik ingress, cluster DNS, Route 53 records, and DNS-01 certificates.
• external-secrets - cluster-side synchronization from AWS Systems Manager Parameter Store.
• tailscale - the operator and per-service proxies that publish private services onto the tailnet.
• forgejo, registry, flux-system - source hosting, the internal OCI registry, build and deploy runners, and staged GitOps reconciliation.
• observability, fleet-reachability - metrics, errors, traces, logs, and cross-site Gatus checks.
• agent-proxy, litellm - the ser8 inference control plane, kept separate from the application cluster.

role:     Senior Platform Engineer
employer: Kapwing

focus:
  - developer platforms
  - agentic tooling
  - observability
  - infrastructure and SRE

background:
  - urfave/cli maintainer
  - government infrastructure
  - multi-cloud platforms
  - engineering management

The homelab spans two physical sites on one Tailscale mesh. Each site runs a small k3s cluster: the application and state plane at the primary site, then the operations and recovery plane at the second. GPU machines join on demand for local inference, while hosted frontier models handle work beyond the small local tier.

The durable choices are simple: isolate state, keep recovery on a different power and network path, make services observable, and assume every compute node except the primary can disappear. This profile keeps the architecture, not point-in-time device and pod dumps.

Go, Python, TypeScript, Bash, C#. AWS, Kubernetes, Terraform, Docker, Tailscale. Prometheus, Grafana, Sentry, OpenTelemetry. Codex, Claude Code, MCP.

2025-now   Kapwing    Senior SWE
2023-2025  Nava       Principal Infra
2022-2023  Textio     Staff Infra
2021-2022  EnergyHub  DevOps EM
2020-2021  Bluelink   Senior Backend
2018-2020  Textio     Senior Infra
2016-2018  Callisto   Senior SWE

Older: Harlot, Quirell/CollectQT, NASA Goddard. Full résumé: coilysiren.me/resume.

coilysiren.me · Bluesky · X · LinkedIn

• AGENTS.md - agent bootstrap guide and operating rules.
• docs/FEATURES.md - inventory of what ships today.
• .ward/ward.yaml - repository command policy.