The setup that still works in six months

The call you will get

A client approves an image in March. In September they want the same scene with the bottle turned slightly. You open your folder, find the prompt, and generate. It is a different picture.

Nothing is broken. Between March and September you updated the interface, a sampler implementation changed a rounding detail, a node pack bumped its defaults, and the checkpoint you used was re-uploaded with the same name and different weights. Every one of these is common, and any one of them is enough.

The five facts that make an image reproducible

Everything else is noise. These are the ones that actually matter:

1. Model hash, not model name. Names are reused constantly. The hash is in the interface’s model list and in the generation metadata.
2. Interface version, as a git commit, not “latest”.
3. Sampler and scheduler names, plus steps, CFG and seed.
4. Every LoRA with its filename, hash and strength.
5. Resolution and any upscaler used.

The interface already writes most of this into the PNG metadata, which is a genuine gift and one most people throw away by exporting to JPEG for the client and deleting the original. Keep the PNG.

Pinning, concretely

For anything you are paid for, treat the setup as a dependency you control.

# in your interface folder
git rev-parse HEAD > ENVIRONMENT.txt          # exact commit
pip freeze >> ENVIRONMENT.txt                 # exact package versions
python --version >> ENVIRONMENT.txt

Then, when a project is approved, copy ENVIRONMENT.txt into the project folder next to the approved PNGs. It is four lines of shell and it converts “I cannot reproduce this” into “check out that commit”.

Do not run git pull in the middle of a project. Update between projects, deliberately, and re-run a known image afterwards to see whether anything moved. This feels excessive until the first time it saves you.

A folder structure that survives

client-name/
  2026-03-brief.md              # the spec, signed off
  refs/                         # the reference pack
  ENVIRONMENT.txt
  models.txt                    # names + hashes of every model used
  gen/
    v01/                        # raw PNGs with metadata intact
    v02/
  work/                         # layered editor files
  deliver/
    hero-1200x1500-v03.jpg

The two rules that make it work: raw generations never get edited in place, and the delivery folder only ever contains files you have actually sent.

The limit of all this

Reproducibility has a hard ceiling on hosted services, and it is worth being clear-eyed. When you call an API, the provider can update the model behind the same name, change a hidden prompt-rewriting step, or retire the version entirely. Several have done all three. Your seed and parameters are recorded faithfully and still produce a different picture, and there is nothing in your folder that can fix it.

This is the strongest practical argument for keeping open weights locally for work that may need revisiting: a checkpoint file on your disk cannot be updated out from under you. It is also an argument for a specific, cheap habit: when work is approved, archive the layered editor file, not just the prompt. A PSD or XCF with the generated plate on its own layer is reproducible by definition, because the pixels are in it.

Keep the file. Prompts are notes; files are assets.

Back it up, because the disk is the single point of failure

Everything above assumes the files still exist. A working image setup is unusual in that most of its bulk (checkpoints, LoRAs, control models) is re-downloadable and therefore not worth backing up, while a tiny fraction of it is irreplaceable.

Back up the small part:

• The raw generated PNGs with their metadata.
• The layered editor files.
• Workflow graphs, ENVIRONMENT.txt, models.txt, the brief.

That is usually a few hundred megabytes per project, which fits anywhere. Excluding the model folders from your backup is the difference between a five-minute sync and an overnight one, and it is the reason people stop backing up at all.

One exception is worth carving out. If a project depended on a community checkpoint or LoRA, archive that file too. Uploads are deleted, accounts close, and a model that a client’s approved campaign depends on can stop existing. A 6 GB file is cheap insurance against a deliverable you cannot ever regenerate.

What “reproducible” honestly means here

Even with everything recorded, exact bit-for-bit reproduction across different hardware is not guaranteed. Floating-point arithmetic is not perfectly associative, GPU kernels differ between vendors and driver versions, and two machines can follow the same seed to visually identical but numerically different images.

For working purposes that is fine: you want the same picture, not the same bytes. Be aware of it when somebody insists a seed produced a different result on their machine: they may be right, and neither of you has done anything wrong.