Coming soon
Run the line, anywhere
pks-agentics-runner
Drop one container where work should run; agents work locally, and your code stays home.
Rented runners mean rented control — and your code on someone else's ground.
When you run agentic assembly lines on a managed runner farm, you push your repo, secrets, and data into a cloud you don't control, and pay by the minute for compute you never own. The control plane and the compute are fused into one product you rent — so where the work runs, what it costs, and who sees the data is someone else's call. We split the two apart. The server coordinates; you run. Your code stays where it belongs.
Managed runner farms hold your compute hostage: you rent it, you don't control it, and you can't move it.
Repo and secrets travel out to a foreign cloud just to let the job run — a data egress you never chose.
Control plane and compute are bundled, so you can't run the work on-prem, on a laptop, or in a closed network.
Three commands. Then it's on the line.
Register the runner
`pks agentics runner register` enrolls a runner identity with the Agentics server for an owner and a project. Add labels to route which jobs land where — and it's authorized to clone the repo without prompting for credentials.
Start it
`pks agentics runner start` polls for tasks, clones the repo, runs the assembly-line stations through an Operator, streams OTLP telemetry back, and posts the results. One container that just does the work.
Scale with more containers
Need more capacity? Launch another container — on another machine, in another cloud, with your own CPU or GPU. Each new container joins the line on its own.
Tear it down
A cleanup command tears the ephemeral state back down when the job is done. No residue, no lingering bill — the container goes away as cleanly as it arrived.
What it does
Just a container
One self-contained container you drop wherever you want the work to run. No agent farm to rent, no sidecar, nothing else to install.
The server only coordinates
The Agentics server handles dispatch, sequencing, and gates — never your repo. The control plane holds the coordination; the compute is yours alone.
Runs anywhere
Your cloud, your server, your laptop, on-prem, or fully air-gapped. The runner assumes nothing about where it lives — it just joins the line.
Operator plus agent, locally
The runner runs the Operator and the agent — e.g. Claude Code via vibecast — on your own hardware, executing each assembly-line station right where the data already is.
Your code never leaves your net
Repo and data stay inside your perimeter. The server only ever sees the coordination — no data egress you didn't choose yourself.
Telemetry you can follow
The runner streams OTLP telemetry back to the server throughout the run and posts the conclusions, so you watch every station live — without handing over the data.
We split control plane and compute on purpose. The server coordinates the work; your container does it. Where it runs and what it costs is your call — not a vendor's.
The runner is one self-contained container and a simple protocol to the server. Nothing managed, nothing to glue together — drop it on a machine and it's on the line.
It runs everywhere because it assumes nothing about its surroundings: cloud, server, laptop, on-prem, or a closed network. Scaling is just more containers on your own CPU or GPU.
It's the living form of "runs everywhere, fully owned". No rented runner farm, no egress you didn't choose — only the work you set in motion, on the machine you picked yourself.
Composes with
The server coordinates. The compute is yours.
pks-agentics-runner is the Runner role of the assembly-line protocol. The Agentics server owns the sequencing, the gates, and the dispatch — but never your code. The runner pulls the task, clones the repo, runs the stations through an Operator, and streams telemetry back. To scale, you launch more containers. Nothing else to install.