Most of the LTX 2.3 workflows covered here are 70 to 200 nodes. This one is 37, and the node count is the point: it is a three-stage image-to-video graph built to fit in available memory rather than to demonstrate everything the model can do.
The graph
| Node | Value |
|---|---|
CheckpointLoaderSimple |
ltx-2.3-22b-dev.safetensors |
LoraLoaderModelOnly |
ltx-2.3-22b-distilled-lora-384.safetensors at 1.0
|
37 nodes for image-to-video with three-stage rendering, NAG, and memory optimisation.
Dev checkpoint, full-strength distillation
Note the combination:
- Checkpoint: dev (non-distilled) build
- Distillation LoRA: 1.0 — full strength
Compare against the transition workflow in an adjacent release, which loads the same dev checkpoint but the distillation LoRA at 0.5.
At 1.0 the distillation dominates. You get the distilled model's efficiency and its conservatism. At 0.5 you get more of the dev model's own motion judgement at the cost of steps.
Which is right depends on the task. For image-to-video with a strong reference, conservatism is usually fine — the reference supplies the content, the model only has to move it. For prompt-driven generation where the model has to invent motion, conservatism becomes "the subject does not move".
NAG in the title, and what it implies
NAG (Normalised Attention Guidance) is a guidance technique that operates on attention rather than on the prediction. It appears in the workflow title but not as a separate loader — it is presumably implemented as node settings inside the graph.
What NAG buys in practice: guidance strength without the oversaturation that high CFG produces. If you have ever pushed guidance to force adherence and gotten a plasticky result, that is the problem NAG addresses.
VRAM optimisation as a design constraint
37 nodes for a three-stage render is tight. A three-stage path normally needs three sampler stages, three sigma schedules, three noise nodes — that alone is nine nodes before any conditioning.
The way this graph fits is by sharing more between stages and by choosing a smaller base geometry. That is a real design trade: fewer nodes means less flexibility and less debuggability, in exchange for running at all on a given card.
Where this is weak
- 37 nodes means almost no validation. A missing model or a bad LoRA weight produces output rather than an error.
- Full-weight distillation is conservative. If your output does not move, this is the first suspect.
- The VRAM optimisation is invisible. The title says it is there; the graph does not annotate which choices are the memory-saving ones, so you cannot safely undo them.
- Three-stage in 37 nodes means the stages are less independent than in a larger graph. Tuning one stage affects the others more than you would expect.
Practical approach
Use this as your baseline image-to-video graph. It runs, it is small, and it exposes the dev-plus-distillation configuration in its simplest form. Once you know what it produces, the larger graphs become easier to reason about — you are adding specific capabilities, not guessing at all of them at once.
Workflows
One graph, published on RunningHub with invite code rh-v1111: LTX 2.3 VBVR image-to-video three-stage render with NAG and VRAM optimisation.
Files
https://huggingface.co/AI-KSK/ksk-video-214-comfyui-workflows
Notes
- Workflow file only. Model weights are not included; each keeps its own licence.
- Tutorial export, not a product.
- Node count and loader values quoted above are read from the published JSON file.
- Independent AI-KSK release. Not affiliated with Lightricks or RunningHub.
Optional API platform - 88API (affiliate link)
Explore 88API for access to multiple AI model APIs. Available models, routes and prices are listed on the platform; Alipay top-ups are supported.
https://88api.ai/sign-up?aff=usx3
Disclosure: I may earn a commission from eligible purchases after you register through this referral link.
Top comments (1)
A 37-node graph makes memory strategy part of the product, not just an implementation detail. I’d publish a peak-VRAM trace for the critical stages and identify which nodes can be recomputed, offloaded, or tiled without changing output semantics. That gives users a practical way to adapt the graph to smaller GPUs instead of treating one successful configuration as universal.