Ino Delay Async

Most of the time you don't want your ComfyUI workflow to sleep on purpose. But automation changes the math. If you're polling a service that takes a moment to finish a job, pacing API calls so you don't trip rate limits, or waiting for a file to land on disk before the next node reads it, a deliberate pause is exactly what the graph is missing. Ino Delay Async is that pause, and the "async" in its name is the whole point: it sleeps without locking up ComfyUI's execution while it waits.

It comes from the Ino Nodes pack (nobandegani), in the workflow-utility category. It's built on ComfyUI's newer V3 schema and behaves like the pack's other relay-style nodes: value goes in, value comes out, and something happens to the timeline in between.

How it works

Under the hood it's an asyncio.sleep on the node's execution, which is ComfyUI's native async style - the process yields while waiting, so other work (a running generation, a background download) keeps going instead of everything grinding to a halt. That's the meaningful difference from a naive sleep node: the delay is real, the deadlock isn't.

The inputs:

• relay - any value of any type, passed through untouched. This is how you keep data flowing while the delay happens; whatever you feed in is exactly what comes out.
• delay - seconds, a float from 0 up to 10000 with 0.1 steps. 0 is an instant passthrough.
• enabled - on by default, with an OFF state that turns the node into a plain relay (no waiting). Handy when you want to keep the delay in the workflow but bypass it without deleting it.

The single output, output, matches whatever type you fed in - so you can drop this node into the middle of any wire without type-matching gymnastics.

Where it earns its keep

The pattern that actually sells this node is waiting on external state. Say your pipeline calls an HTTP node that kicks off a job and returns a job ID, then needs the result after the job finishes - a few seconds of delay between the poll attempts is the idiomatic way to build that. Same for file staging: a process outside ComfyUI writes a file, and you don't want the next node reading before the write is flushed. A delay node converts "hope the timing works out" into "guaranteed minimum wait."

The honest caveat: it's a fixed sleep, not a conditional wait. If you need "wait until X is true," you still need logic around it - this just gives you the breathing room between checks. And 10000 seconds is a lot of napping; if you find yourself near that max, the workflow design is usually the problem, not the delay.

Installing it

It ships with the whole Ino Nodes pack, so install that once. ComfyUI Manager: search "ComfyUI Ino Nodes", install, restart. Or manually:

cd ComfyUI/custom_nodes
git clone https://github.com/nobandegani/ComfyUI-InoNodes.git
cd comfyui_ino_nodes
pip install -r requirements.txt

Restart ComfyUI after. The pack is entirely on the V3 node schema (README requires ComfyUI v0.18.1+), and pip install -r requirements.txt is required - the pack's own inopyutils library is what every node imports under the hood.

Common issues

If the delay seems to do nothing, check the enabled toggle first - OFF is a straight passthrough. If a workflow feels like it's hanging, make sure the sleep is where you think it is; a 60-second delay upstream of a long generation means you pay it before the generation. Search "Ino Delay Async" in the node menu (it's under the pack's extra/workflow nodes).