Cooldown -IMAGE-

Cooldown -IMAGE- is a custom node whose entire job is to receive an image, wait a few seconds, and hand the same image back. The whole pack is about forty lines of Python, and the secret ingredient is Python's built-in time.sleep(). No models, no CUDA kernels, no dependencies. If you've ever wanted a workflow to slow down on purpose, this is the tool.

The honest answer to "why would I want that?" is that most people don't - this is a niche utility, not a workflow staple. But there are real situations where a deliberate pause is exactly the trick:

• You run ComfyUI as a backend/API and a client blasts the queue with jobs. A cooldown between image generations spaces the load out instead of letting the whole queue dump onto your GPU at once.
• You're feeding frames into a video or animation pipeline that generates faster than the next stage - or your eyes - can keep up.
• You're pushing images to a downstream service (an uploader, captioner, or remote API) that rate-limits per second. A beat between images keeps you under the limit.

How it works. The mechanism is right there in the source, and it's the whole node:

def main(self, IMAGE, sleep):
    time.sleep(sleep)
    return (IMAGE,)

The image tensor comes in, the node sleeps for sleep seconds, and the identical tensor goes out. Nothing is modified, resized, or regenerated. The node is marked as an output node (OUTPUT_NODE = True), so ComfyUI treats it as a terminal result and shows you the image that came out the other side.

The inputs that matter - there are only two:

• IMAGE - the tensor that flows through. It's flagged forceInput, meaning you can't type a value in; it has to be wired from upstream, like a KSampler or VAE Decode.
• sleep - the delay in seconds. Default 1, min 0, max 300. That's a five-minute cap; if you need longer, chain two nodes.

The output is a single IMAGE, identical to the input, just late. Wire it into your Save Image node or anything else that follows - the cooldown can sit anywhere in the chain without disturbing the pipeline.

Where people get burned: the sleep is blocking. ComfyUI runs the graph top to bottom, and while this node sleeps it holds its queue slot and ties up the worker. A 300-second sleep on a busy backend means that job's slot is locked for five minutes. Great for pacing, wrong tool if you want true async scheduling - this is deliberately serial.

One more thing to know: because the IMAGE input is required and the node is an output node, ComfyUI keeps that image tensor resident for the entire sleep. On a big batch that's a chunk of VRAM sitting there doing nothing. That's the price of the trick.

Install. ComfyUI Manager is the easy path - search for "ComfyUI Cooldown Node" and hit install, then restart. Or clone it manually into custom_nodes:

cd ComfyUI/custom_nodes
git clone https://github.com/tuki0918/ComfyUI_Cooldown_Node

Restart ComfyUI and the three Cooldown nodes appear under the Cooldown category in the node menu. There's no requirements.txt, no model downloads, nothing to break - which, in a custom-node ecosystem where dependency conflicts are the number one complaint, is genuinely refreshing. This is one of those quiet little nodes nobody posts about on Reddit; you find it by googling when you need it. And when you do, it just works.