The open core is public

Today I pushed the core of stepaway to github.com/augustinbegue/stepaway under AGPL-3.0. It’s the part that does the actual work: taking a live Claude Code session off my laptop, running it on a machine I own, and bringing it back.

I’ve been building this in the open for a while, but until now “in the open” meant screenshots and a waitlist form. Now it means you can read the code, run it on your own cluster, and tell me where it’s wrong.

What a handoff actually moves

The thing I keep having to explain: this is not “run the agent in the cloud.” Every first-party cloud-agent feature I’ve tried wants a clean tree and a fresh container. It clones your repo at HEAD, builds an image, and starts a new conversation. That’s a different product. It’s fine for “open a PR that fixes this issue.” It’s useless for the state I’m actually in at 6pm.

The state I’m actually in at 6pm is: a half-finished refactor across fourteen modified files, three untracked scratch files I haven’t decided about, a Postgres volume seeded with the fixture data that took forty minutes to get right, a .env full of secrets resolved from my vault, and a conversation where the agent already knows why we abandoned the first approach.

stepaway moves that. Repo and dirty files byte-identical, transcript, env files, docker volumes. The agent wakes up on the runner mid-task and references its own earlier reasoning without being re-briefed. That’s the fidelity thesis, and it’s the only reason this exists. If the handoff loses the uncommitted refactor, or the seeded database, or the resolved secrets, or the last hour of conversation, you haven’t moved the session — you’ve started a new one and lied about it.

What’s in the repo

The stepaway CLI. Zero runtime dependencies, and — the part I’m most pleased with — kubectl-free. Earlier versions shelled out to kubectl for exec and port-forward, which meant every user needed a working kubeconfig and a matching client binary. It now talks to the backend over plain HTTPS. Install:

npm i -g https://stepaway.dev/stepaway.tgz

An in-cluster backend. Bun + Hono, a REST + SSE /v1 API. One pod and one PVC per session, no shared state between them. Sessions move through a small state machine — pending → restoring → ready → running → done | failed — and every transition is observable on the SSE stream, which is what the CLI’s progress output is actually rendering. Having a real state machine instead of a pile of booleans is what made the restore path debuggable.

A Helm chart.

helm repo add stepaway https://stepaway.dev/charts
helm install stepaway stepaway/stepaway -n stepaway --create-namespace

RBAC is namespace-scoped by default — the backend can create pods and PVCs in its own namespace and nothing else. Resource quotas and network policies are in the chart but opt-in, because I’d rather you turn on the restrictions deliberately than have the install silently fail on a cluster with a different CNI. CI publishes the server image to ghcr.io/augustinbegue/stepaway-server using the workflow’s own GITHUB_TOKEN — no personal access token in the repo secrets, which is one fewer credential I have to rotate and one fewer way to leak push access to everything I own.

Why AGPL

Open core, AGPL-3.0. The runner, the protocol, and the transfer logic are the part that has to be inspectable — it’s handling your uncommitted work and your secrets, and “trust me” is not an acceptable answer for that. Run it entirely on your own hardware and never talk to me at all; that path is supported and I use it myself. The managed side is what I’ll charge for, later.

What’s next

Two things, in order.

A prebaked runner template image. Cold start is currently dominated by booting a plain base image and installing a working toolchain on it — about ninety seconds before the agent types anything. A template image with the runtime and agent CLI already baked in should get that to roughly a second. That’s the difference between “hand off and wait” and “hand off and close the lid,” and until it’s fixed the product doesn’t feel like what it says on the tin.

A web UI on the /v1 API. The SSE stream already carries everything a UI would need — state transitions, transcript, session list. I want to peek at a running session from my phone without opening a terminal. Building the API before the UI wasn’t discipline, it was laziness, but it worked out.

Then the closed beta. The waitlist is on stepaway.dev. If you run your own cluster and you’ve been annoyed by exactly this problem, that’s the person I’m building it for — go read the code and open an issue.