LTX 2.3 API and Local Workflow for Builders

I’ve been routing LTX 2.3 jobs through two paths for the last three weeks: an API call from a small Node service, and a local checkpoint running on a single workstation GPU. This piece is what I learned about when each path earns its place, and where each one starts to cost you.

If you’re a builder shipping a product that touches video generation, your decision is rarely “which model is best.” It’s more often “where does this model live in my stack, and what breaks first when load goes up.” LTX 2.3 makes that question more interesting than it used to be, because it lives in both worlds — a hosted API and a fully open checkpoint — without forcing you to pick one forever.

Here’s what I tested, what I logged, and where I’d send other builders looking at LTX 2.3 right now.

Why LTX 2.3 is the current builder focus

LTX 2 as background: release and open-source timeline

LTX 2 dropped in October 2025 as Lightricks’ synchronized audio-video foundation model — DiT-based, native 4K, up to 50 fps. The full open-source weights followed in January 2026. That release window matters because it gave the community three months to build node integrations, fine-tuning workflows, and quantized variants before LTX 2.3 arrived.

If you’re new to the LTX line, the short version: LTX 2 was the architecture statement. LTX 2.3 is the version where the architecture starts to feel production-ready.

What changed with LTX 2.3

LTX 2.3 shipped on March 5, 2026. It’s a 22-billion parameter checkpoint with a rebuilt VAE, cleaner audio generation, native portrait (9:16) support, and stronger prompt adherence — particularly on multi-subject scenes and timing cues. Two main variants ship: a full dev checkpoint for training and LoRA work, and a distilled 8-step version for faster inference. The official LTX 2.3 model page documents the variants, license tiers, and supported endpoints.

If you’d already integrated LTX 2, the 2.3 upgrade isn’t a re-platform. The API shape is similar and the weights swap is mostly a checkpoint change. The improvements you’ll feel first are texture stability across frames and noticeably less audio artifacting.

Why synchronized audio changes video workflows

Most video models still treat audio as a downstream step — generate the clip, then run TTS or a separate music model, then mux. LTX 2.3 produces both in a single pass, which collapses two pipeline steps into one. For builders, that means fewer service dependencies, fewer race conditions, fewer “the audio is 200ms off and nobody knows why” tickets.

Synchronized doesn’t mean perfect. Voice fidelity still trails dedicated TTS for any application where the user expects studio-grade dialogue. But for ambient sound, motion-correlated audio, and scene-level audio cues, the single-pass approach held up in my tests.

API vs local workflow

When to use LTX API access

The API path is the right call when you don’t have GPU operations expertise on the team, when your traffic is unpredictable enough that idle GPUs would be expensive, or when you need to ship before your devops budget catches up to the model size. LTX 2.3 is large enough that local serving has real infrastructure cost — the API removes that from your critical path.

I paused here when I first sized this up: the temptation is to go local for unit economics, but if your usage is bursty and your team is small, the hosted API usually wins on total cost for the first six months.

When Hugging Face or local inference makes sense

The Lightricks/LTX-2.3 model card on Hugging Face hosts the official weights and supports diffusers integration. Quantized variants — including GGUF builds and fp8 versions — exist for builders running on lower-VRAM hardware. The full dev checkpoint is around 47GB; the fp8 variant brings that closer to 18GB.

Local makes sense when you have steady, predictable volume; when you need to fine-tune or LoRA-train; when your data can’t leave your infrastructure for compliance reasons; or when your unit economics only work below a per-second API rate. For LoRA work specifically, the model is documented to train motion, style, or likeness adaptations in under an hour in many configurations — which is the part that makes local inference compelling beyond cost alone.

Where LTX Director or desktop workflows fit

LTX Desktop is the local NLE wrapped around the LTX 2.3 engine — useful for solo creators or small teams that want a timeline-based editor without writing code. Separately, the community has produced node-based extensions like LTX Director (an open-source ComfyUI workflow building on earlier LTX Sequencer and Kijai’s Prompt Relay work). LTX Director isn’t a Lightricks product; it’s an indie layer that turns LTX 2.3 generation into a more editable, sequencer-style workflow.

For builders, these are mostly reference points. They’re useful for seeing what production-grade UX on top of the model looks like, but you’d typically integrate at the model or API layer rather than wrap the desktop tools.

How builders should test LTX 2.3

Start with prompt and image-to-video tests

Two tests will tell you more in a day than two weeks of reading benchmarks. First: send your existing prompt set — the ones you’ve already validated on whatever model you’re currently using — and compare outputs head-to-head. Second: run image-to-video on a set of real reference images from your product, not curated demo images. The gap between demo-quality input and production-quality input is where most model evaluations fail.

Evaluate audio-video sync and prompt adherence

For audio, generate a handful of scenes with explicit motion and audio cues in the prompt — footsteps, doors closing, environment ambience. Listen for drift between the visual event and the audio event. The 2.3 release reduced this drift noticeably from 2.0, but it’s worth confirming on your scene types.

For prompt adherence, build a small benchmark set covering single subject, multi-subject, timing cues (“after three seconds, the camera pans”), and spatial relationships. Score these on a binary “does it follow the prompt” basis. Aesthetic scoring is too noisy until you’ve passed the adherence floor.

Track latency, queue behavior, and failed generations

API-side, log p50/p95/p99 latency, queue times during peak hours, and the rate of failed or retried generations. Local-side, log VRAM headroom, inference time per second of output video, and OOM frequency. Hypothesis confirmed for me after a week: the API smooths out tail latency better than my single-GPU local setup, but local has zero queue cost.

Prompt guide for production testing

Prompt structure for motion and scene control

LTX 2.3 responds better to prompts that separate scene description from motion description than to single dense prompts. A working pattern: lead with subject and environment, then specify camera motion, then specify subject motion, then specify audio cues. The Lightricks/LTX-Video GitHub repo hosts reference workflows you can adapt — there isn’t a standalone “LTX 2 prompt guide” doc published yet, but the LTX-2 technical paper on arXiv covers the text connector architecture in detail.

Audio-led prompting considerations

When audio is the lead element of the scene — say, a character speaking, or a specific sound effect driving the motion — put the audio description before the visual description in the prompt. The model treats early-prompt tokens with more weight, and audio-led scenes tend to drift visually if the audio is described as an afterthought.

What to log during model evaluation

Log the seed, the full prompt, the model variant, the inference parameters, and the output URL for every generation. Without these, you can’t reproduce a good output a week later when you want to study what made it work. This sounds obvious. In practice, most evaluation pipelines I’ve seen skip the seed.

LTX 2.3 vs Hunyuan Video

Audio-video model vs video generation model

LTX 2.3 and Hunyuan Video are both open-source video foundation models, but they solve different problems. LTX 2.3 generates synchronized audio and video in one pass. Hunyuan Video, in both its original 13B and the lighter 8.3B HunyuanVideo-1.5 variants, generates video only — audio is a separate step. For builders, that’s the first thing that determines which one fits your product surface.

Dimension	LTX 2.3	Hunyuan Video
Native audio	Yes	No
Parameters	22B	13B (HV) / 8.3B (HV-1.5)
Open license	LTX-2 community license	Tencent open-source license
Local deploy	Yes (weights on HF)	Yes (weights on HF)
Best for	Audio-led scenes, single-pass production	Strong visual fidelity, motion diversity

Hunyuan Video is different from Hunyuan 3D

The naming gets confused often enough that it’s worth saying out loud: Tencent’s HunyuanVideo GitHub repository is the video generation model. Hunyuan 3D is a separate Tencent line for 3D asset generation. They share the Hunyuan family name and almost nothing else architecturally. If you’re benchmarking video models, this is the repo to pull from.

When to route across both models

Some builders run both. LTX 2.3 for scenes where audio is central — character dialogue, sound-driven motion, ambience-led storytelling. Hunyuan Video for scenes where visual motion fidelity matters more than audio, or where you already have a separate, more controllable audio pipeline in place. Routing logic at the application layer makes more sense than trying to force one model to do everything. A unified generation layer like WaveSpeedAI helps here — you can hit both endpoints through one API surface and switch by scene type, without rebuilding integration for each provider.

FAQ

Can commercial teams use LTX 2.3 locally?

Yes, but check the license terms. LTX 2.3 ships under the LTX-2 community license, which has different provisions for commercial use depending on company size and deployment type. Don’t take any blog post — including this one — as legal guidance. Read the license text on the official model page, and reach out to Lightricks if your deployment is ambiguous.

How do developers run LTX 2.3 locally?

The fastest path: pull the weights from Hugging Face, install the LTX-Video codebase (Python 3.12+, CUDA 12.7+, PyTorch 2.7), and either run inference through the official pipelines or use the ComfyUI-LTXVideo nodes. Quantized variants are available if your GPU can’t fit the full 47GB checkpoint. The official model page has the current install instructions — those are more reliable than any third-party walkthrough.

Does LTX 2.3 replace separate audio and video tools?

For some workflows, yes. For others, no. Synchronized generation removes the need for a separate TTS or sound model in many scene types — but if your application requires precise voice control, lip sync to specific phonemes, or studio-grade dialogue, dedicated audio tools still hold ground. My current setup uses LTX 2.3 for ambient and motion-correlated audio, and routes to a separate TTS model when the user needs specific voice control.

When should builders use LTX 2.3 instead of Hunyuan Video?

When audio is part of the output you ship to users, when you want one generation call instead of two, or when your scenes are short enough that the synchronized-generation pass keeps latency acceptable. Hunyuan Video is still strong for visual-only generation and has a mature ecosystem of LoRAs and community workflows. The choice isn’t either/or — it’s where each model lives in your pipeline.

Previous posts: