LTX Director (TJ 2.5)

LTX Director (TJ 2.5) puts a scrubbable timeline inside a ComfyUI node: blocks you drag to set what happens when, each with its own prompt, or an image, or a video for motion guidance. It's the community's answer to a real hole. LTX has been capable of time-windowed conditioning for a while, but stock ComfyUI had no sane way to say "this, then that, at this second", so people built wrappers around the feature instead. WhatDreamsCost's LTX Director became the well-known one - Director 2.0 pulled a few hundred upvotes and added IC-LoRA, retake mode and audio inpainting. This node is that lineage, copied rather than depended on: the pack vendors CGlide's LTX-2.5-Director fork and renames its keys *TJ25. It's why the whole package went GPL-3.0.

How the prompt relay works

The interesting part isn't the editor, it's what the editor feeds. Each prompt segment gets a token range from the global prompt, and the node builds a temporal penalty matrix over cross-attention so a segment's tokens only attend near the frames they belong to - sigma per segment is 1/ln(1/epsilon), so epsilon is the only knob that shapes how hard the boundary is. Below about 0.1 everything is effectively sharp, which is why the default 0.001 behaves like a hard wall; 0.5 and up softens the transitions between segments.

That mask gets applied through a patched clone of your model (the node returns that clone), so the sampler has to run on this node's model output, not the loader's. Wire the loader straight to your KSampler and the relay is a no-op - the timeline will look like it's doing nothing, because it is.

Image segments go a different route: they become guide_data - a list of images, insert frames, and strengths - which the LTX Director Guide node later splices into the latent with the VAE. So the pair is Director for the plan, Guide for the pixels.

The fields worth your attention

• model / clip - the LTX model and text encoder; the node tokenises through clip to map your prompt text onto frames.
• global_prompt - conditions the whole video and anchors characters and scene context. This exists so your segment prompts don't have to repeat the character description on every line.
• epsilon - boundary sharpness, as above.
• start_second / end_second / duration_seconds / start_frame / end_frame - the render window, kept in sync.
• duration_frames - the author is explicit that this sets the timeline's visual scale only; the actual frame count is read from the latent. Setting it to 240 doesn't get you 240 frames.
• timeline_data / local_prompts / segment_lengths / guide_strength - auto-populated by the editor. Don't hand-edit the JSON.
• custom_width / custom_height / resize_method / divisible_by - image segments get resized to the target; divisible_by 32 is the LTX-friendly default.
• audio_vae / use_custom_audio / inpaint_audio / override_audio - the audio side, for timelines with an audio track or gaps worth filling.
• start / end / duration - connection-only automation sockets that override the panel when wired. Nice for batch renders, invisible otherwise.

Outputs: model, positive, negative, video_latent (an empty latent, only when you don't feed optional_latent), audio_latent, guide_data, motion_guide_data, frame_rate, combined_audio. The usual chain is model and the conditioning into the Guide node, guide_data and motion_guide_data into it too, then the Guide's outputs into the sampler.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/designloves2/ComfyUI-TJ_NODE_STUDIO_ONE.git

Restart, then run bash install_requirements.sh (install_requirements.bat on Windows) once and restart again - the pack's other custom-node packs don't install through Manager. The Director side leans on core ComfyUI's LTXV nodes, on ComfyUI-LTXVideo for the IC-LoRA motion path, and imports PyAV at load time.

Where it goes wrong

The one I'd bet on: your segment_lengths count not matching your local prompt count. That raises outright - "Number of segment_lengths must match number of local prompts" - so if a render dies on validation, count your segments. And because duration_frames is cosmetic, a timeline that looks ten seconds long can render five: the latent wins, every time.

The honest caveat about nodes like this comes from the other side of the community: convenience wrappers hide the parameters you need when output goes sideways. This one hides a lot. When something is off, drop to a plain graph for one comparison render before you start guessing at epsilon.