[ product — pure serverless GPU · live-fire receipts ]
SSH in and run anything — any library, any training job, any inference engine. When the work stops, the VM parks itself: process tree, RAM, and VRAM freeze into one signed artifact and billing stops the same second. Your next request starts it back — state intact, counters continuing.
Not functions, not containers-as-a-service — a real GPU VM with a lifecycle your work controls. The state layer underneath is what makes “serverless” honest: idle doesn't lose your work, it freezes it.
01
A request starts it
First SSH hit or API call boots your GPU VM. If a parked artifact exists, state wakes with it — in seconds, not a cold model load.
02
It's a real VM
Full SSH: torch, JAX, raw CUDA, axolotl, vLLM, sglang, ComfyUI — anything you'd run on a box you own. Nothing is wrapped away.
03
Idle parks it
When work stops, the lane freezes the process tree, RAM, and VRAM into one signed artifact and stops the VM. Billing stops the same second.
04
The next request wakes it
The VM starts and the artifact restores byte-exact — sessions continue where they froze (receipted: workload counters continue across death).
05
Upgrades are park → wake
Need a bigger GPU mid-project? Park, wake on different hardware — even a different architecture (receipted: RTX PRO 6000 → H100, 17/17).
This is the move nobody else has: your workload isn't welded to the box it started on. Park it, and wake it somewhere better — the artifact is the portability.
[ receipt · D20 — live migration ]
Same session, different machine
A running workload parked on one box, prefetched (4.3 s) and woken on a second machine in 22.7 s — canary byte-exact, workload counter continuing (29→31) across the hop. That's the live-flip primitive: move to a bigger VM the moment you need it.
[ receipt · D23 — cross-architecture ]
Even a different GPU generation
Parked on RTX PRO 6000 (Blackwell sm120), woken on H100 (Hopper sm90): counters continued, the buffer returned byte-exact at its original virtual address, all kernel arms live — 17/17 checks. Per-app cross-arch lands app-by-app with per-app receipts; the substrate is proven.
[ receipt · D25 — the downgrade answer ]
And a clean no when the target is too small
Moving down gets a pre-flight fit gate, not a mystery OOM: before anything touches the new box we compare the parked workload's frozen VRAM and GPU topology against the target and refuse with exact numbers — "holds 32 GiB, target GPU has 14 GiB free" or "uses 8 GPUs, target has 1" — while your parked state stays safe to wake on a machine that fits. Receipted end-to-end with a 32 GiB workload: refused with the reason, failed loudly (never silently) when forced, then woke byte-exact once the target was freed up.
Every app below is live-fire receipted or honestly queued. “Natively supported” means park/wake is transparent to the app and we hold a byte-exactness receipt; per-app cross-arch ships only after that app's own receipt.
| App / layer | Status | Byte-identical proof (receipt) | Cross-arch |
|---|---|---|---|
| ComfyUIlisted | Natively supported | LTX-13B video generation preempted mid-sampling, parked, powered off, restored cross-VM — resumed at the dump step and produced a bit-identical video (sha-verified)D12 · 2026-09-29 | adapter queued |
| vLLMlisted | Natively supported | 6000-token request IN FLIGHT across park/wake completed byte-identically on the restored socket (8 GiB VRAM drained and refilled)D16d · 2026-10-01 | adapter queued |
| sglanglisted | Natively supported | in-flight request AND a mid-flush SSE stream resumed byte-exact on the restored tree (scheduler + detokenizer, 6000/6000 tokens)D16e/f · 2026-10-01 | adapter queued |
| Jupyterlisted | Natively supported | live kernel RAM byte-exact (magic + array sha identical); the tick thread CONTINUED (counter 10→263) across park/wake, original + regression both greenD16b · 2026-10-01 | adapter queued |
| Ollamalisted | Partial — boundary registered | park green; the llama-server runner dies post-restore (the registered multi-process CUDA boundary: a child owning the context)D16c · 2026-10-01Honest partial — the boundary is registered with a fix path (per-process quiesce), not shipped as supported. | adapter queued |
| PyTorch (training) | Natively supported | torch 2.14 image (5.6 GiB rootfs) with a 2 GiB allocator-pool canary: pool alive, canary byte-exact after park/wakeD19b · 2026-10-03 | adapter queued |
| Blender | Natively supported | headless EEVEE render parked mid-frame, resumed AT the dump point — output pixel-identical to the clean-run frame (max_diff=0)D16a · 2026-10-01Receipted off-catalog — queued to be listed. | adapter queued |
| Docker + GPU (substrate)substratelisted | Natively supported | docker-managed GPU container: VRAM sha identical after kill + wipe; cross-VM wake from object storage alone (24 s, disk wiped on target); driver skew 580.178 → 580.173 byte-exactD18b / D18-cross / D-skew · 2026-10-02..04 | substrate proven (D23) |
| CUDA kernel launches (substrate)substratelisted | Natively supported | pre-loaded CUDA modules and their launches ride park/wake — the first kernel-launch receipts (sm120 and H100 sm90 both green)D22 · 2026-10-05 | substrate proven (D23) |
| Cross-architecture migration (substrate)substratelisted | Natively supported | parked on RTX PRO 6000 (Blackwell sm120), woke on H100 (Hopper sm90): counters continue, canary byte-exact at the original virtual address, all kernel arms rc=0 — 17/17; multi-GPU both directions on top (2× RTX6000 ⇄ 2× H100, driver-identical, per-child pid + counter continuity)D23 · D24 · D25 · 2026-10-06Per-app cross-arch ships app-by-app as adapters land — each app gets its own receipt before it's called supported. PTX up-JIT (older arch → newer GPU) loads natively; the arms belt is mandatory only in the down direction. Down-migrations run the pre-flight fit gate (D25): device-count/topology and per-child frozen-VRAM vs the target's free VRAM — refused with exact numbers, artifact untouched; TP re-shard across a park remains the honest boundary. | native (exec-bridge) |
| InvokeAIlisted | Natively supported | parked mid-generation on RTX PRO 6000 (w5 lane, cuda_plugin drain — the 5.3 GiB mid-render state), killed+wiped, woke from GCS in 34 s with the VRAM state refilled (3611 MiB), and the resumed 1024²/500-step render COMPLETED after the wake; the idle roundtrip's post-wake generation was pixel-identical (PIXEL_DIFF 0 of 786432) and byte-exact vs the parked process's own last render. D27: deployed through the platform's own launcher (parkable by default, no hand-built argv), TWO full park→wipe→wake migration loops with FOUR consecutive byte-exact renders (same md5), the woken container RE-PARKED clean (2.0 s checkpoint) and woke green again with its network re-attached (health probe against the restored bridge IP in 3 ms). D28: the full circle ran the PRODUCTION chain — marketplace deploy through the live CP → park 23.7 s (the app served traffic through the whole park) → wipe → wake 25.0 s with the GPU context restored (same 642 MiB footprint, health probe answered 2 ms after the CRIU restore) → 200 to external users. D29: the console's Stop/Start buttons now park and wake for real — Stop saved the app's full state to GCS inside the click (parked:true + manifest URI in the response), Start restored it with the SAME container id (woken:true, health 200) — live E2E through the prod CP, no per-app configD26 · D27 · D28 · D29 · 2026-10-06/07Deployed through the universal parkable launcher: every platform deploy (catalog, custom image, git repo) and every SSH-user `laz-run` launch composes the same PID-1 wrapper — device-node conversion before cuInit, chmod 666, then exec of the original entrypoint — so apps are park-capable from birth with zero per-app adapters and zero app-side config. The D26 gaps are closed: re-park of a woken container is green (pipe-stdio wake), the secrets gate classifies before any downgrade, and woken containers are now network-attached (post-restore netns attach — veth + bridge IP + DNAT; pre-D27 wakes were process-healthy but network-isolated). | same-arch receipted (w5 lane); cross-arch adapter queued |
| VS Code Server | Queued for testing | — not yet testedCatalog 'available soon' — test lands with the listing. | adapter queued |
| TensorBoard | Queued for testing | — not yet testedCatalog 'available soon' — test lands with the listing. | adapter queued |
| Gradio | Queued for testing | — not yet testedCatalog 'available soon' — test lands with the listing. | adapter queued |
| Streamlit | Queued for testing | — not yet testedCatalog 'available soon' — test lands with the listing. | adapter queued |
| Label Studio | Queued for testing | — not yet testedCatalog 'available soon' — test lands with the listing. | adapter queued |
Receipts are public at /benchmarks/park — the same drills this matrix is built from.
The test catalog mirrors real users — each app below is brought in and receipted before it's called supported. Queued items are next in line, not promises.
Researchers
Students
Content creators
Training
Inference teams
We're onboarding serverless-GPU beta users in waves — capacity is real hardware, so a human approves each seat. Once you're in:
Beta feedback shapes the roadmap: which apps to receipt next, which GPU shapes to stock, what the auto-stop policy should default to.
Not zero-downtime
Park→wake is a real gap — seconds, published per workload class on the benchmarks page. Serverless here means $0-when-idle with state that survives, not teleportation.
Per-app cross-arch rolls out app-by-app
The substrate is receipted (D23: sm120 → sm90, 17/17). An app is only called cross-arch-supported once THAT app has its own receipt — adapters land one at a time.
Parked ≠ free storage
GPU billing stops at park; the artifact rests in object storage at storage rates — cheap, itemized, not hidden in the GPU price.
Beta ≠ free hardware
The $50 credit is real money for real GPU-seconds. Capacity is limited and approval is human — we'd rather say no than oversubscribe the beta.
Per-second billing, $0 idle, byte-exact state. The receipts are public — the beta is open in waves.