IAMCCS Cine FLF Timeline Sequencer

Long LTX videos have a reliability problem that no amount of prompting fixes: the model holds together for a few seconds and then drifts. The community workaround, which LTX has supported since 0.9.5's keyframe conditioning, is to drop reference frames into the generation - not just a first frame, but guides at specific moments that keep the model honest. IAMCCS Cine LTX Sequencer is this pack's friendly wrapper around exactly that: you give it a timeline and a batch of guide images, and it injects them into the video latent at the right times with per-keyframe strength.

The display name ("Cine FLF Timeline Sequencer") tells you the lineage - FLF = first/last-frame conditioning, the filmmaker-style workflow where you plan key moments in a scene rather than hoping a single text prompt carries a 200-frame shot.

How it works

The core mechanism is guide insertion, the same LTXVAddGuide-style logic the community rediscovered as the real power move for LTX. Here's the flow:

1. Parse timeline_data - JSON (keyframes/rows) or simple pipe lines: second | ref | strength | label | camera note.
2. Take the batched guide images from multi_input (wire a reference loader upstream; each image is one keyframe candidate).
3. For each timeline entry, encode the reference image with the video VAE and splice it into the latent at the computed frame position, patching the positive/negative conditioning and the noise mask.
4. Respect per-keyframe strength, image-lock, and motion-force values; if the timeline is empty, fall back to fallback_num_images spread across duration_seconds at fallback_strength.

The tail_safety_frames input (default 1) reserves the end of the latent so a guide doesn't overrun the sequence - the pack's own tail-frame obsession shows up here.

The inputs that matter

• positive, negative - the conditioning to be patched.
• vae - the LTX video VAE used to encode guides.
• latent - the video latent being built (typically a full-length empty latent at your resolution).
• multi_input - your batched guide images, one per slot.
• timeline_data - the plan; edited by the Cine FLF timeline UI in the author's workflows.
• duration_seconds, frame_rate - the shot's length in real time.
• fallback_strength (0.82) - used when a timeline line has no strength.

Outputs: patched positive, negative, latent, and a report.

Install

Part of IAMCCS-nodes:

cd ComfyUI/custom_nodes
git clone https://github.com/IAMCCS/IAMCCS-nodes.git

or Manager → search IAMCCS. README floor: ComfyUI ≥ 0.3.0, Python ≥ 3.12, Torch ≥ 2.8. You also need the native LTX nodes (they ship with recent ComfyUI) - the node is a wrapper around that machinery, not a replacement.

Where people get burned

• Too many, too strong guides. Every injected frame is a promise the model must reconcile. Strength 1.0 on every keyframe can produce "slideshow" motion where the video jumps between anchors. Lower strengths (0.6–0.85) and fewer guides give smoother results.
• Guides that overrun the latent. If your timeline's last keyframe lands at or past tail_safety_frames before the end, the conditioning can exceed the latent length - the pack's own LTXSequencerExact raises an assert for exactly this. Keep the last guide inside the safety margin.
• Reference resolution mismatch. Guides get VAE-encoded at the latent's spatial size; if your reference loader hands up wildly different aspect ratios, expect the guides to look soft. Pre-resize references to your generation resolution.
• Treating it as a text-to-video node. It patches an existing latent and conditioning - you still need the whole sampler chain (empty latent, sampler, VAE decode) around it. The author's SuperNodes exist to compress that; this node alone is one component.
• Zero search impressions, one-author tooling, and the README barely documents the Cine family - the report output and the timeline tooltips are your best docs.