♻️ ImageSentinel

If you've ever overwritten an image in ComfyUI's input folder, hit queue, and watched the built-in Load Image hand you the old version, you already know the pain this node exists for. ComfyUI's stock loader reads the file once and caches it; re-running the graph doesn't re-read the disk. ♻️ ImageSentinel is the fix: it watches a single image file and only re-executes - and re-loads - when the file's contents actually change.

The name sounds grander than the reality, but that's fine. It's one node, no plugin, no API, no model files. You point it at a folder and a filename, and it becomes the input bridge between ComfyUI and whatever external editor you work in.

What it's actually for

ImageSentinel is the low-tech cousin of the Photoshop-to-ComfyUI bridge nodes that got attention a couple of years back - the ones that stream your canvas over a remote connection. Those are neat but fragile: they need a plugin on the editor side, a password, a port. ImageSentinel works with anything that can save a file. Photoshop, Krita, Clip Studio, Blender, a text editor writing a config - if it writes a PNG, JPG, or PSD to disk, this node picks it up.

The killer workflow is img2img iteration: paint a rough mask or layout in Krita, save, hit queue, and Comfy re-draws it. Save a corrected version, hit queue again. Because the node detects the change, you don't get stuck feeding stale input into a sampler.

How it works

The mechanism is a ComfyUI trick called IS_CHANGED. Before every run, ComfyUI asks each node "did you change?" - if the answer is no, it serves the cached output and skips the whole downstream graph. ImageSentinel answers with the SHA-256 hash of the file's bytes. File overwritten → new hash → the node re-executes and everything after it does too. File untouched → hash matches → no-op.

That's also why the README harps on fixed seeds. If your KSampler has a random seed, it changes every run regardless, forcing re-execution and wasting a resample on input that didn't move. Fix the seed and the "nothing changed" case actually costs you nothing.

Two more details worth knowing. The optional delay_seconds sleeps before the hash check - it exists so an external app (read: Photoshop's slow save) finishes writing before the node looks. But the sleep runs on every execution, changed or not, so keep it small; 0.5–1s is plenty. And PSDs are flattened via psd-tools' composite(), so you get the merged RGB image, not layer access.

Inputs and outputs

• folder_path (required, string) - the directory holding the file. Defaults to ./ComfyUI/input.
• image_name (required, string) - the exact filename to watch, e.g. sketch.png or project.psd.
• delay_seconds (optional, float, 0–300) - pause before the change check. For instant queue mode.

That's the whole config surface. The single IMAGE output is a standard (1, H, W, 3) float tensor, so it plugs into anything that accepts an image: VAE encode, img2img, ControlNet preprocessors, a Preview node. Wire it wherever you'd normally put Load Image.

Installing

The pack is registered on the Comfy registry, so ComfyUI Manager → Install Custom Nodes → search "ImageSentinel" is the easy path. Manual install is the usual dance:

cd ComfyUI/custom_nodes
git clone https://github.com/VertexAnomaly/ComfyUI_ImageSentinel
cd ComfyUI_ImageSentinel
pip install -r requirements.txt

Then restart ComfyUI. Dependencies are psd-tools, Pillow, numpy, torch - all already present in most installs except psd-tools, which is a light pure-Python package. No checkpoints, no LoRAs, nothing to download.

Where people get burned

The failsafe is a double-edged sword: if the file can't be found or fails to load, the node returns a black 512×512 placeholder instead of erroring. Your workflow keeps running - silently feeding a black square downstream. If your output suddenly goes dark, check the terminal for a [ImageSentinel] File not found line before you blame the model.

Also remember it watches exactly one file, and it reads the whole file into memory to hash it on every run. A multi-gigabyte PSD gets read fully each execution, which is a little wasteful but usually fine. Keep the watch folder on a fast disk if you're running big sources, and don't set delay_seconds higher than you need - that's real queue time every single run.