KSampler Sequence

The trick this node packages is older than the node's own docs suggest, and it's the reason there's a whole genre of ComfyUI workflows from 2023 that produce wobbling morph videos. Run the sampler. Take the latent it gave you. Feed it back in at a lower denoise with a different prompt. Do that twenty times.

That loop, written out by hand, is a dozen nodes and a headache. KSampler Sequence is the loop: run the sampler once per iteration, stack the results into one latent batch, and let a prompt schedule decide what each iteration is chasing.

What comes out and what you do with it

One output, latent, and it's a batch - one latent per loop, in order. Decode that batch and save it as frames. There's no video node involved, no ffmpeg, no timing: you're making a numbered image sequence that happens to be related to itself.

Which is the honest framing of what this is. Each loop starts from the previous latent at a lower denoise, so the run reads as movement rather than as unrelated images. But nothing in the model knows about time, and no amount of latent interpolation changes that. This is the AnimateDiff-era approach, and AnimateDiff's own rationale - temporal motion modules bolted onto an image model - got replaced by video models that actually generate frames. Keep expectations accordingly: this is for prompt travel, morphs and short loops, and it's great at those.

The inputs that matter

positive_seq and negative_seq are the schedules, and they're a CONDITIONING_SEQ - a list of frame-tagged conditionings, which is exactly what CLIP Text Encode Sequence (Advanced) emits. A loop with no entry of its own keeps the last one it was given, so a prompt stays in force until the next index. And the negative side needs at least one entry at frame 0, because a loop with nothing to fall back on has no negative prompt at all.

sequence_loop_count is how many frames you get. steps times that is what you're actually asking the GPU to do, so 20 loops at 20 steps is 400 steps of work - budget it.

latent_image is the starting point and sets the size of every frame. An empty latent generates from scratch; an encoded image starts the sequence on that picture.

denoise_start is how much of the first loop is redrawn (1.0 ignores latent_image and generates from noise; ~0.5 keeps its composition), and denoise_seq is the per-loop value for everything after. This is the knob that decides whether the run drifts gently or jumps from frame to frame - 0.2 barely moves, 0.5 is a visible change, near 1.0 and each frame is a fresh image.

seed_mode_seq moves the seed per loop: increment/decrement step by one and keep consecutive frames close, random makes every frame its own image, fixed holds one seed so only the prompt and denoise change anything. alternate_values is the fun one - on by default, it runs every other loop on a second seed drifting away from the first, which reads as flicker between two looks and, in a short sequence, as movement.

Then the two "make it less jumpy" switches. use_conditioning_slerp with cond_slerp_strength blends each loop's conditioning toward the previous one, turning a cut between prompts into a glide - 0.0 keeps the previous prompt, 1.0 takes the new one whole. use_latent_interpolation with latent_interp_strength mixes the new latent back toward the last frame; Blend is a straight average while Slerp travels the arc between the two and holds contrast better. unsample_latents goes further and runs the sampler backwards over the previous frame before resampling, giving the new prompt something to re-resolve - at roughly double the time per loop.

Installing it

Part of WAS Node Suite v3 (MIT, WASasquatch), so:

cd ComfyUI/custom_nodes
git clone https://github.com/WASasquatch/was-node-suite-comfyui.git

Or ComfyUI Manager, searching WAS Node Suite v3. ComfyUI 0.14.0+ and Python 3.10+; the pack installs no packages and fetches nothing, so this isn't one of those packs that can half-install. If the sequence samplers are missing from your Add Node menu, look at the extras feature group in <ComfyUI user dir>/was-node-suite/config.yaml - it's on by default, and it also gates the LUT and latent-upscale nodes.

What bites people

Loops that drift bright. Because each frame starts from the last, contrast and detail accumulate over a long run; that's the characteristic look of chained latent resampling and the reason the interpolation and denoise controls exist. If you need forty frames, drop denoise_seq and interpolate rather than pushing through.

Forgetting there are two ways to smooth a sequence. Conditioning slerp smooths what you asked for; latent interpolation smooths what you got. Turning on both and blaming the sampler for a mushy result is a rite of passage.

And the one that gets everyone eventually: fixed seed, low denoise, one prompt, and the run converges on a single image and then holds it. That's the ladder running out of rungs. Turn on alternate_values or raise denoise_seq.

There's also a v2 of this node. If a workflow from 2026 asks for KSampler Sequence (v2), it pairs with CLIP Text Encode Sequence (v2) and drives off keyframes rather than a loop count - they're different nodes, and the sockets don't match.