onefrontieronefrontier.ai

the launch harness · open source

It will launch.

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.

one · handoff · vast-4x6000 10:49
  1. pull the image
  2. weights 184 GiB
  3. load 46 GiB/card
  4. warmup cuda graph
  5. profile kv cache
  6. serving :30000

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

worker serving · 162 tok/s concurrent · queue 0 · kv 723k · ttft 84 ms

paced, not filmed — these are the lines the machine reads

why it will

We know because we ran it.

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.

launch shapes
20a model, an engine, a class, an argv
served argv
18the flags that actually ran
measured cells
6a capture, never an estimate
estimates
0a gap stays a gap

Read the rows: the launch cards carry every shape, and the catalog is where each number is held.

the harness

A launch is a state machine, not a prayer.

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.

  1. 01 pull 15 min pulling image · image present
  2. 02 weights 30 min downloading · download complete
  3. 03 load 20 min loading weights · weights resident
  4. 04 warmup 15 min capturing cuda graph · graph captured
  5. 05 profile 5 min kv cache · max_total_tokens
  6. 06 serving 60 min server started · ready to serve

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

Two doors in. Neither needs our account.

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.

Wrap your line.

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 4
no shell function of ours in the hot path

Bake your image.

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

One run, three faces.

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

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

02 · headless

A receipt, and your shell back.

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

Read it back from anywhere.

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

It will launch.

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.