Reload Latent

Reload Latent loads a latent that a previous run saved to disk and drops it back into the current graph. It's the piece that lets one queue press pick up where the last one left off - you run a workflow, it writes a latent out, and next time Reload Latent reads that same file and hands it to your sampler. That's how Cyclist turns ComfyUI's "repeat this workflow" button into an actual iterative loop that builds on itself instead of regenerating from scratch each time.

You can't just draw a wire from the end of your graph back to the start, because ComfyUI won't run a graph with a cycle in it - the execution engine needs a DAG. Cyclist closes the loop through storage instead: Save Latent (Override) writes the latent at the end of the run, Reload Latent reads it at the start of the next one, and neither node forms an illegal edge. The classic use is progressive latent upscaling - nudge resolution up a notch per pass, save, reload, repeat, until you hit the size you want. In one graph that's N stacked upscale-plus-sample chains; as a loop it's one chain you press Queue on N times.

How it works

This is a disk node, and that distinction matters within this pack. Cyclist splits into two families: the "Recall/Memorize" nodes keep values in RAM (fast, but wiped on restart), while the "Reload/Save" nodes persist to your ComfyUI output folder. Reload Latent is the disk side - Save Latent (Override) writes to output/latent under a fixed filename with no auto-incrementing counter, so the file just gets overwritten each pass, and Reload Latent reads that exact filename back. Because it's on disk, the loop survives a restart, unlike the in-memory Recall nodes.

Inputs and outputs

There are only two inputs, and only one you really tune:

• filename (string, default ForLoop_1) - the name of the latent file to load from your output folder. It has to match the filename your Save Latent (Override) node is writing, or you'll load the wrong file (or nothing). Drive both from a single Loop Manager loop_id if you don't want to hand-sync them.
• fallback (LATENT, optional) - what to output when the file doesn't exist yet, which is exactly the situation on the first iteration before anything's been saved. Wire an Empty Latent Image (or your starting latent) in here so pass one has something to chew on. Leave it empty and the first run has nothing to reload.

The output is a LATENT that plugs straight into a KSampler's latent_image, a latent upscale, a VAE Decode - anywhere a latent normally flows.

Installing it

Grab it from ComfyUI Manager: open Manager, search comfyui-cyclist, install, restart. Or do it by hand:

cd ComfyUI/custom_nodes
git clone https://github.com/Pos13/comfyui-cyclist

and restart ComfyUI. There are no model downloads and no bulky dependencies - Cyclist is pure workflow plumbing, so you dodge the usual custom-node install pain where each new pack brings a requirements.txt that quietly conflicts with something already in your environment.

Fair warning: the repo is archived. Its author (Postpos on Civitai) has stated they won't be maintaining it. It still runs on current ComfyUI, but if a future core update changes how latents are saved and nothing gets patched, that's on you. For a small loop-helper the risk is modest - just know there's no one home if it breaks.

Common issues

The single biggest source of confusion is the filename mismatch between save and reload. Save under one name, reload under another, and the reload silently falls back forever while you wonder why the loop never accumulates. Keep the two identical; a Loop Manager feeding both is the clean fix.

Watch the first pass. Until Save Latent has run once, the file genuinely doesn't exist, so without a fallback wired in your loop has no seed to start from. This is the number-one "it does nothing on the first queue" complaint, and it's a wiring gap, not a bug.

Mind where you put the Interrupt node if you're using one to stop the loop. Cyclist's own guidance is to place Interrupt right after the important Reload node, and only after whatever produces its inputs - ComfyUI won't run a graph that folds a true cycle back on itself, so the stop logic has to sit downstream of the reload. And if you're building a progressive-upscale loop, remember the general upscaling rule: each pass adds pixels the model has to invent, so push resolution in modest steps and keep denoise low on later passes, or you'll drift off your original instead of sharpening it. Reload Latent's only job is to hand the file back faithfully; when the loop misbehaves, the fault is almost always the filename, the missing fallback, or the interrupt placement, not the node.