# Five ideas, and that's the whole model.

> A nest is one working setup packed with everything its run depended on; a manifest lists every file in it with a sha256 checksum; a restore reinstalls that setup on another machine rather than copying a disk; and a hand-off gives a nest to another account without a public link or a storage key.

Canonical page: https://renest.ai/docs-concepts.html

<h2 id="nest">A nest is one working setup, packed</h2>

<p>A <strong>nest</strong> is one working setup, packed. Not a folder of files — a folder
of files tells you what you had, it doesn't tell you whether it ever ran. A nest holds
everything the run depended on: model weights and adapters, every custom node's source
archived in full and pinned to the commit it was at, the dependency lock, and the workflow
or training config that produced the result.</p>

<p>Renest only packs setups that <strong>already worked</strong>. It doesn't diagnose an
unfamiliar setup, and it doesn't judge whether two nodes are compatible. It reproduces what
ran; it doesn't try to get strangers running.</p>

<h2 id="manifest">The manifest is the whole state of a nest</h2>

<p>The manifest is one JSON file listing every part of the nest with the sha256 checksum of
its bytes, where it can be fetched from, and how to put it back. It's the whole state —
there is no hidden database on our side that you'd need in order to restore. Its shape is
written down in the <a href="format-spec.html">format spec</a>, and it carries a version
number that has to go up whenever the shape changes.</p>

<h2 id="addressing">Every file is named after its own bytes</h2>

<p>Files are stored under the checksum of their contents — <code>blobs/sha256/&lt;first two
characters&gt;/&lt;checksum&gt;</code> — not under the name someone gave them. Two
consequences, and both are the point:</p>

<ul>
  <li><strong>The same bytes are never stored or sent twice.</strong> The base model you and
  a thousand other people use is one object, not a thousand copies.</li>
  <li><strong>A restore can check what came back</strong> instead of assuming it. Each file
  is checked against its recorded checksum on the way back, and a file that doesn't match
  is fetched again or reported, never kept silently.</li>
</ul>

<p>The checksum is sha256, and it stays sha256 — the same one Hugging Face and Civitai use,
so a file you already have is recognisably the same file.</p>

<h2 id="rebuild">A restore reinstalls the setup; it doesn't copy a machine</h2>

<p>A restore is not a disk image. Python packages are reinstalled from the lock, custom
nodes are unpacked from the source archives that travel inside the nest (nothing is cloned
from their repositories), and weights are fetched by checksum. That is why a nest packed on
one card can be restored on a different card, in a different datacentre, on a different
cloud — and why the pre-flight check can tell you in advance when it <em>can't</em> (a setup
built for one GPU generation genuinely will not run on hardware it was never compiled for;
you get told before the download, not after).</p>

<p>What comes back is the files and dependencies, checked. Whether the app then produces
output on that machine is what the restore's final step shows you, by running the packed
workflow once — see <a href="docs-three-gates.html">Three gates, not an exit code</a>.</p>

<h2 id="handoff">A hand-off gives a nest to another account, never through a public link</h2>

<p>A <strong>hand-off</strong> gives someone else a nest without either of you exchanging
storage keys. You issue a code; they redeem it; the nest lands in their library. The code
can be revoked and it's tied to an account on both ends. Issuing hand-off codes depends on
your plan, and so does the number of claims one code allows — there is no unlimited option.
A code stops when the claims run out, when it expires, or when you revoke it.
<a href="docs-handoff.html">How hand-offs work</a> covers the details.</p>

<p>Files whose licence doesn't allow it don't travel. A model that came with restrictions
is not copied to the person you hand off to — they get its address and its checksum, and
fetch it themselves under their own terms. Your own material (a LoRA you trained, your own
images) goes across once you declare it with <code>--mine</code> when you pack; see
<a href="docs-capture.html#mine">Capture a run</a>.</p>

<p>It is deliberately <em>not</em> a public link. There is no "copy public URL" anywhere in
Renest — a nest can contain licensed weights, and a public mirror of those is someone
else's redistribution problem becoming yours.</p>

<p>What a hand-off does not do: it doesn't vouch for what's inside. Restoring someone
else's nest runs their custom nodes on your machine, so Renest tells you who sent it and
makes you say you trust them — by name — before it runs any setup step from a stranger.</p>