01 · the screen
The ladder and the tail.
Six rungs on the left, the child's own output on the right, and the clock the stage is spending. This is the face the hero shows.
one handoff python serve.py --tp 4
the launch harness · open source
Not the model — the launch. The image that pulls, the checkpoint that finishes, the tensor-parallel width that fits, the port that was still free. We ran it enough times to know the failures by name, so the harness reads its own log and answers.
pulling image localinferencelab/vllm:jovian-judgement-community-20260910-r34
pulled image — 18.4 GB in 00:00:51
downloading 184 GiB across 96 shards
download complete in 00:06:12
loading weights shard 96/96
weights resident — 46.2 GiB/card on 4 cards
capturing cuda graph (batch 1..64)
graph captured in 00:01:38
kv cache sized — 33,989,623,808 bytes
max_total_tokens=723136
server started on 0.0.0.0:30000
engine ready — ttft 84 ms
paced, not filmed — these are the lines the machine reads
why it will
A launch card is one model's shape on real hardware: the engine and its version, the image, the flags, the tensor-parallel width — and, where the run was kept, the argv that was served. 18 argv are recorded. 6 cells have been measured end to end; the rest print owed instead of a number, and never a guess.
Read the rows: the launch cards carry every shape, and the catalog is where each number is held.
the harness
one reads the child's own output and moves a stage only when a line names it. The tracker never walks backwards, so an out-of-order line costs a longer stage and never a false one — and a stage that goes quiet has a deadline instead of a shrug.
the keeper — launch, die, ask, restart
A dead launch is not an ending. The keeper loops to a budget — five attempts, twenty minutes unless the Launchfile says otherwise — and every attempt lands in the same journal, so the record shows the flake and the retry that answered it.
The Launchfile carries the intent (a tune, the floors, a ceiling); the container carries the engine; the journal carries what happened.
Today the answer comes from the kit's own rule table; the agent endpoint replaces it — one model preloaded with the failure classes and the catalog's rows, so a launch that fails on a shape it has seen before gets the fix rather than a stack trace.
integration
Wrap the command you already type, or bake the image you already have. The harness does not care which — it reads the same log, walks the same six stages, and leaves the same journal.
One word in front of the launch, in your own shell. The argv goes through verbatim — no re-quoting, no eval, and a quoted payload arrives as one word.
# ~/.zshrc alias launch='one handoff' # the line you already type, now with a record launch python serve.py --tp 4no shell function of ours in the hot path
One validated row in, one reproducible image out: the base image pinned by digest, the engine version the row names, the flags that ran, the weights already inside. Docker by name, catalog row by source.
# from a validated catalog row package/cell/build.sh \ glm-5.3-flash rtx-pro-6000-x4 # then your own Dockerfile can sit on top FROM <the image it printed> ENTRYPOINT ["one", "handoff", "/serve.sh"]the entrypoint is yours; the record is kept
Both doors reach the same place: an engine on a port, a tunnel to it, and a run that a later reader can reconstruct. The launch kit walks the whole path.
the run
The same launch, watched from wherever you happen to be standing: at the screen, away from it, or reading it back afterwards. The journal is the record in every case — the faces only decide how much of it you see while it happens.
01 · the screen
Six rungs on the left, the child's own output on the right, and the clock the stage is spending. This is the face the hero shows.
one handoff python serve.py --tp 4
02 · headless
Detached, the launch outlives the terminal it started in. Every event mirrors to stdout as JSON for the thing that is watching, so CI reads a launch like any other step.
one handoff --detach python serve.py one handoff --json python serve.py
03 · the record
The journal is append-only: a start before the spawn, a spawn, the phases, the exit — and the exit row survives a kill -9 of the wrapper itself. The box's own console reads the same rows.
# $XDG_STATE_HOME/one/
events.jsonl the strip
Worker health rides one row at the bottom of the screen, and only while a launch is live: state, tokens, queue, the KV pool, time-to-first-token. It never takes the keyboard — you keep typing in the shell above it, and the row leaves when the run ends.
worker serving · 162 tok/s · queue 0 · kv 723k · ttft 84 ms
the first sentence
Rent the GPU, know it fits, serve it over a tunnel — that was always the second sentence. The harness is what lets you say it without crossing your fingers.
Open source, your keys, no vendor inside the path — and a record of every run either way.