SeedIncrementerNode

SeedIncrementerNode is a small utility that does exactly what the name promises: it takes a seed and hands back the seed plus a subseed, incrementing by a fixed amount each time the graph runs. Four outputs - seed as string, seed as int, subseed as string, subseed as int - so you can feed the exact type your sampler wants. It's the node for "I don't want random, I want the next one."

The point of working through seeds methodically is reproducibility. Random seed per run is fine for exploration, but the moment you want to A/B test a prompt across a sequence of seeds, or revisit a specific seed later, you want a deterministic progression. This node gives you that: run 1 gets seed N, run 2 gets N+10, and you can reconstruct exactly which seed produced which image from the run count. The subseed output exists because some samplers use a secondary seed (for the noisiest stage of sampling or as part of the variation machinery) - if yours doesn't, ignore it.

How it works

Trivial arithmetic and formatting:

• seed (INT, required) - the starting seed.
• IncrementAt (INT, default 10) - how much to add each run. 1 gives you sequential seeds; 10 spaces them out; anything works.

Outputs:

• STRING - the current seed as text (handy for logging or prompt templates).
• INT - the current seed as an integer, for the sampler's seed input.
• STRING - the subseed as text.
• INT - the subseed as an integer, for samplers that take subseed.

The incrementing happens per execution - every time the workflow runs, the stored seed advances by IncrementAt. That's the behavior to keep in mind: it's stateful across runs, which is the feature, and also the thing that will confuse you if you re-run a workflow expecting the same seed twice.

When to use it

Batch sweeps and comparison work. Generate with seed 100, 110, 120... by re-running, keeping everything else fixed, and you get a clean progression where each image's seed is a simple formula away. Pair it with the pack's StepCfgIncrementNode if you're also stepping CFG and steps across a batch - together they turn a single re-run loop into a poor man's grid search. For pure exploration, use ComfyUI's built-in random seed instead; this node's whole value is the opposite of random.

Install and notes

Install the pack once: ComfyUI Manager → search "ComfyUI-LexTools", or git clone https://github.com/SOELexicon/ComfyUI-LexTools into custom_nodes, restart. No models, no dependencies beyond core.

One honest note: it's a convenience wrapper, not a unique capability - ComfyUI's own seed node plus an increment math node does the same thing. What you're paying for is having all four outputs and the increment logic in one box, which is genuinely tidier when you're mid-workflow and just want the progression without building it. The statefulness is the gotcha; if a run produces the same seed you expected last time, check whether the node actually re-executed.