Remote Int (GeN13)

Here's the little ritual every big ComfyUI graph grows. You've got a seed that needs to hit the sampler, the second pass sampler, the filename, and a note. So you convert each widget to an input and drag four wires off one Primitive - or four separate primitives, and then you change three of them by mistake and spend twenty minutes figuring out why pass two doesn't match pass one.

Remote Int (GeN13) is the same idea without the wires. Drop one where you need the number, give it a channel name, drop another somewhere else, give it the same name. They are now clones: change the value on any one of them and the rest follow instantly. No connection on the canvas at all.

The fields

Two required widgets and one output. That's the whole node.

• channel - the group name, default remote. This is the only thing you have to think about. Same type, same name = same group. Remote Int on channel res does not sync with Remote Float on channel res, which is correct: a 1024 pixel width and a 1.024 float aren't the same value and you don't want them aliasing.
• value - an integer, ±1,000,000,000. Edit it on any clone; the group updates at once.
• control_after_generate - fixed, increment, decrement, randomize. This is shared across the group too, and it fires once per queue for the group, not once per node. That's the detail that makes the node genuinely useful for seeds: randomize on the group gives you a fresh value every queue, and every clone sees the same fresh value, so you can't get a sampler and its second pass disagreeing.

Output: INT, the shared value.

What "clone" covers

Value, the after-generate action, and bypass. Bypass is the one people underestimate. You've got a refiner branch with a Remote Int on it; bypassing one clone takes the whole group out, including the copies you'd have to scroll three screens to find. Same for anything tucked inside a subgraph - the README calls that out specifically, and it's the case where a physical wire is genuinely impossible to run, because you can't easily wire across a subgraph boundary and back.

The synchronisation is entirely frontend. The backend node just returns whatever value it was handed, so save/load, workflow embedding, and API execution all behave the way you'd expect - there's no hidden server state to go stale.

Where it earns its keep

Seeds and step counts, mostly. Anything you'd otherwise paste into five widgets. A two-pass image workflow is the canonical case: pass one at 24 steps with seed X, pass two at 12 steps with seed X, and both numbers live in two places each with no wire between them. Move the graph around and nothing breaks.

Second case: the numbers that live in a second row of your canvas where you can't see them. Rather than hunting for the widget, put a clone next to where you're working and edit that.

Third: tiles and batches. index-type values that get threaded into several nodes at once - Load Latest Image Private's index, a Counter's reset, a Switch Any's selection.

Installing

Manager → search GeN13 → install → restart. Manual:

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

requirements.txt is one line - nvidia-ml-py, for the pack's monitor strip. The remotes are JavaScript plus a trivial Python class. No models, nothing to download. Portable installs: python_embeded\python.exe -m pip install -r ComfyUI-GeN13/requirements.txt.

The honest trade-off

Wire-hiding convenience nodes have a real cost, and this ecosystem has argued about it for years. When a value travels on a wire you can see that the sampler is connected to the thing that owns the seed. When it travels through a channel name, a typo - remote vs Remote, or two graphs that both use the default remote for different purposes - silently desyncs your numbers and the graph still looks fine.

Two habits fix it: name channels like variables (res, seed_main, shot_index) and never leave two nodes on the default remote that mean different things. There's also a right-click convert that turns a core Primitive into the Remote version in place, which is the fastest way to retrofit an existing graph.

If you want one value feeding many wires and you don't mind the wires, core's typed primitives are the boring correct answer. Remote Int is for the graphs where the wires have become the problem.