The problem

Every rented GPU starts from zero.

You rent the machine by the hour — then spend the first hours making it feel like yours again. Three ways the same evening goes wrong.

The first hours

Rebuilding it by hand, again.

Fresh machine, empty disk. pip resolves a different set of versions than it did last week, the custom nodes have moved on, and every model downloads again.

The meter runs long before the first render does.

The next card

“Works on my pod” isn’t a promise.

A different card, a newer GPU generation — and the setup that ran last night stops with an error nobody can explain, on the morning it was due.

You can’t promise a delivery when you can’t promise your own environment.

The monthly bill

A network volume stays where it is.

It lives in one region, on one provider. It can’t follow you to a cheaper card somewhere else, and it can’t be handed to anyone.

It bills every night, including the nights nothing runs.

So we built the opposite Not a bigger freezer — a way to rebuild, and check. ↓

The method

We don’t freeze machines. We rebuild them.

A nest isn’t a disk image. It’s the recipe of a run that already worked — the files, the locked dependencies and the workflow — captured once, kept in your drive, and rebuilt on whatever you rent next.

What we promise is the files and dependencies coming back, each one checked. Whether it then runs is something we test on every restore and report back — not something we assume.

  1. Step 01 · Capture

    Take the recipe off the machine that works.

    On the machine where a ComfyUI run — or a kohya_ss / LLaMA-Factory fine-tune — already works, one command (or one button in the ComfyUI panel) records the models, the custom nodes, the locked dependencies and the workflow. Every file is recorded by its own content on the way in, so “roughly the same” can’t sneak aboard.

    6.46 GBalready stored, skipped
    38.8 sto send the other 447 MB

    Repacking a ComfyUI + SDXL run whose model file an earlier nest had already stored. Upload segment only, one run. field report

  2. Step 02 · Store

    It waits in storage, not on a machine.

    The nest lands in your drive, filed by content instead of by filename. A file that is already stored is never stored twice, and only files the drive hasn’t seen travel. Nothing runs, so nothing bills by the hour.

    23.5 GBkept from a failed upload
    11 MiBsent on the next try

    A 23 GB video nest: the files a failed earlier upload had already stored were not sent again. One run. field report

  3. Step 03 · Check

    Judge the machine before you spend time on it.

    Before anything downloads, the restore checks the machine you just rented against what the nest was packed on. A pairing that cannot work — say, a GPU generation the packed code was never built for — is refused up front, not twenty minutes into a dependency install.

    free diskGPU driverGPU generationsystem libraries the nest needs

  4. Step 04 · Restore

    Rebuild by the recipe, check every file, run it once.

    One command on the new machine. It walks these stages in order and tells you which one stopped, if one does:

    • checking this machine
    • downloading
    • putting files in place
    • installing dependencies
    • starting up
    • test render

    Every file is checked against its fingerprint as it lands. Then the app starts and your workflow runs once — and at the end it prints where the output is and how to open the app yourself. Lost the machine halfway? The same command works on another one.

    6–8 mina 6.5 GB nest
    13.0 mina 23 GB nest

    Door to door: boot, transfer, dependency install, verification and a first render. The 6.5 GB nest held one model and no custom nodes; the 23 GB video nest was one run on the same GPU model. field report · field report

Open format · Apache-2.0

All of it lands in an open format. Every nest ships a plain restore.sh that brings back its files and dependencies with zero Renest code — so your work never depends on us still being here. the escape hatch

Why it holds

Numbers you can check, not slogans.

Every figure below comes from a published report, with the hardware and the sample size next to it. The full record of every restore we have run — failures included — is on the Proof page.

Determinism

Files are guaranteed. Images are honest.

Every file is checked byte for byte on the way in — that part we guarantee. Images depend on the hardware: on the same GPU model and CPU brand, rebuilt renders have come back as the same file; with a different CPU brand they differ by a hair, the same way every time.

0pixels differ
0.981439similarity, on every Intel host we measured

rendered images compared by fingerprint across hosts field report

A different card

A recipe, not a frozen disk.

Dependencies are installed again for the card you landed on, so a nest isn’t tied to the card it was packed on. Where the model of GPU changes, expect slight, stable differences in the output — and the pre-check refuses the pairings that cannot work at all.

Other GPU modelslight, stable differences — about 94% similar on video

a 23 GB video nest rebuilt on an A10 and on an Ada card guide

Resilience

Cut off halfway? It picks up where it stopped.

Uploads and downloads resume instead of starting over, and a file that fails its check is fetched again on its own.

23.5 GBkept from a failed upload
11 MiBsent on the next try

A 23 GB video nest: the files a failed earlier upload had already stored were not sent again. One run. field report

Across machines and regions

Restored where the GPUs are.

Each route below comes from a published report and says whether it timed the whole rebuild door to door or only the transfer.

Field reports

Door-to-door times include boot, dependency install and verification; the Mbps figure is the transfer segment alone. Single runs — each report states its sample size.

Canada → Sweden13.0 min door to door · 23 GB

US-West drive → Japan867 Mbps transfer

RunPod → Vast7.3 min door to door · 6.5 GB

Questions

When is a move actually finished?

When is a move actually finished?

Not when the files are back — when the app works. A restore checks every file against its checksum, then starts ComfyUI, runs your workflow once and reports what passed, naming any custom node that failed to load because a system library is missing. Our own results, failures included, are on the Proof page.

When is a move finished

Watch it happen on a machine you chose.

Claim a starter nest — a run we packed and checked — restore it on a machine you rent, and read the result yourself. Free, no card.