LTX-2.5 Video Prompting for Beginners: Full Guide With Timestamps

Making an AI image is relatively intuitive: describe what you want the frame to look like.

Video asks you to direct what happens over time.

Someone moves. The camera follows them. A door opens. A dog runs into the ocean. Dialogue happens in a certain order. Lighting changes. Sound has to line up with movement. The subject still needs to look like the same subject five seconds later.

That was the central lesson from our LTX-2.5 livestream with LTX Chief Product Officer Daniel Berkovitz and VP of Product Alon Yaar: better AI video comes from thinking like a director, then giving the model the right mix of instructions and references.

This guide reorganizes the full livestream into a beginner workflow you can actually use. Every major lesson links to the exact moment in the video.

If you liked our earlier AI for Total Beginners livestream guide, think of this as the video version.

First up, the TL;DR

• What LTX-2.5 actually is (1:53): Daniel describes LTX as an open, multimodal world model with audio, video, and keyframe capabilities.
• What changed in 2.5 (4:05): faster generation, better prompt understanding, stronger pixel quality, new keyframe handling, and a new decoder.
• How professional studios use it (7:30): VFX, animation, avatars, color grading, social media, and physical AI all showed up in partner workflows.
• AI-generated animation in-betweens (12:17): artists make the important keyframes, while a customized LTX model generates the frames between them.
• What makes a good first prompt (15:29): start simple and iterate, or describe the full scene in a structured way.
• Why references can beat text (17:43): poses, video, audio, blocking animations, and keyframes can communicate intent more directly than prose.
• How to try LTX without building anything (21:18): LTX Explore gives beginners a visual interface for testing the model.
• The anatomy of a strong video prompt (23:22): subject, action, environment, camera, lighting, and sound.
• How to iterate on a shot (24:44): change the instruction that matters, regenerate, and keep steering.
• How to keep a character consistent (26:56): start from an image or video reference when text alone is too loose.
• Audio-to-video demo (28:21): audio alone can strongly steer timing, expression, and motion.
• How inpainting and video extension fit in (30:47): modify parts of an existing video or continue footage while preserving its visual logic.
• Retake and morph-cut demo (33:29): regenerate the ugly gap between two clips instead of hiding it with B-roll.
• How little data a fine-tune can sometimes need (38:26): Daniel says useful specialized behavior can appear with surprisingly small clip sets, depending on the task.
• The best approach for recurring characters (39:28): train a LoRA for the character or use a consistent image-generation workflow before image-to-video.
• When audio should drive the generation (41:42): use it when timing, performance, or animation needs to follow an existing track.
• Will it follow a script? (43:19): yes, although multiple characters make dialogue assignment harder.
• How long should a normal clip be? (44:51): the team recommends roughly 20 seconds for normal use, with specialized workflows going longer.
• Why LTX calls itself a world model (47:13): predicting future visual states can be adapted beyond filmmaking, including robotics research.
• How to connect several shots coherently (48:34): storyboard images and consistent first frames give you more control than independent generations.
• Where multi-shot generation gets trickier (49:46): you can prompt connected scenes directly, but the team says it is harder to steer.
• What local hardware helps (53:40): more VRAM reduces offloading, though community setups can run below the team's preferred hardware.
• Where beginners should get sample prompts (55:24): LTX Explore preloads example prompts and assets so you can modify something that already works.

What changed in LTX-2.5

Daniel opened with an important distinction at 1:53: LTX thinks of the system as a multimodal world model, not simply a text-to-video generator.

In the livestream, he described LTX-2.5 as a 22 billion-parameter model built around video, audio, and keyframes. He also said the company kept the model open because developers and studios need to customize it for workflows LTX itself may never package as a product.

The 2.5 release pushed in two directions at once.

First, speed. Daniel said the improved distilled model can generate a 10-second video in under seven seconds on the team's setup. His explanation for caring about speed was more interesting than the benchmark itself: waiting minutes between generations turns direction into a queue. Fast generation lets you steer.

Second, quality. The team added higher-quality keyframes during generation, changed the decoder, and reworked captioning and prompt enhancement. Daniel said those changes reduce temporal artifacts and improve sharpness and coherence.

That follows the direction we saw when LTX 2.3 moved the company's open video stack onto desktop workflows. LTX is trying to make generative video behave more like production software: fast enough to iterate, open enough to modify, and structured enough to slot into existing pipelines.

Step 1: Think in shots, not pictures

At 15:29, a viewer asked what actually makes a great first prompt.

Daniel gave two valid approaches.

The first is simple: start with the core idea and let the output tell you what is missing.

His example was a spinning car. The first generation moved too slowly, so he added a stronger instruction about speed. You can do the same with camera movement, framing, lighting, action, or sound.

The second approach is more deliberate. Describe the scene in a structured order:

• What does the scene look like?
• What actions happen, and in what order?
• What style are you going for?
• How does the camera move?
• What sounds should exist?
• Is anyone speaking?

That lines up with LTX's official prompting guide, which recommends describing events over time and giving concrete camera and audio direction.

The useful mental shift is straightforward: an image prompt describes a frame; a video prompt describes a shot.

Step 2: Use this beginner video-prompt formula

During the live demo at 23:22, Alon zoomed in on a Dalmatian prompt and explained its pieces.

A good beginner structure is:

1. Subject + action: What are we watching, and what is it doing?
2. Environment: Where is this happening?
3. Look and tone: What should the scene feel like?
4. Camera: How is the shot framed, and how does the camera move?
5. Lighting: What light shapes the scene?
6. Audio: What should we hear?

A simple template:

[SHOT TYPE] of [SUBJECT] [ACTION] in [ENVIRONMENT].

The scene has [VISUAL STYLE / ATMOSPHERE / LIGHTING].

The camera [CAMERA MOVEMENT], keeping [SUBJECT] [FRAMING / POSITION].

Audio: [AMBIENT SOUND / MUSIC / DIALOGUE / SOUND EFFECTS].

Example:

A medium tracking shot of a golden retriever sprinting along a windy beach at sunset.

The scene has warm golden light, wet reflective sand, and gentle ocean mist.

The camera tracks beside the dog at running speed with a shallow depth of field.

Audio: crashing waves, wind, paws hitting wet sand, and distant gulls.

You do not need every field for every generation. Include the details that remove ambiguity around the things you care about.

Free LTX-2.5 Starter Prompt Pack

Want to skip the blank page? We made 32 starter prompt templates for cinematic shots, dialogue, product videos, social clips, reference-driven generation, and multi-shot scenes.

• Get the PDF version
• Get the Microsoft Word version

Pick a template, replace the bracketed fields with your idea, then iterate from the first result.

Step 3: Direct by iteration

The Dalmatian demo accidentally showed the best beginner workflow.

Alon generated a dog running beside a camper van. At 24:44, he added one instruction: have the dog eventually run into the water.

Then he generated again.

The dog ran into the water.

The important part is what he didn't do. He did not throw away the prompt and start over.

Treat the first result like a rough take. Pick the highest-impact problem, then change one variable:

• Make the movement faster.
• Lower the camera.
• Change daylight to dusk.
• Have the subject turn left.
• Add a line of dialogue.
• Increase the energy of the action.

This is why speed matters. A seven-second render benchmark sounds like infrastructure trivia until you realize it changes the creative loop from "submit and wait" to "direct and adjust."

Step 4: When words get awkward, use another modality

Alon made one of the most useful admissions of the stream at 17:43: prompting is hard.

Artists often know what they want visually and struggle to translate that idea into a paragraph. The LTX team has been building ways to communicate intent without forcing every idea through text.

They mentioned several alternatives:

• Image conditioning: establish the exact character, composition, or starting frame.
• Video conditioning: give the model movement or structure to follow.
• Pose references: show a body position instead of describing it.
• 3D blocking: create rough geometry or motion that defines the camera path and object placement.
• Keyframes: specify important visual states along the timeline.
• Audio conditioning: let an existing performance determine timing and expression.

Imagine you need a character to raise a hand in a precise way at second two. You can spend a paragraph describing the motion, or show the model a reference.

That is a deeper shift in AI video prompting. The best prompt may be a package of references rather than one giant text box.

Step 5: Use audio when performance matters

At 28:21, Alon loaded two things:

• A still image of a puppet version of Corey.
• An audio clip of actual Corey speaking.

Then he generated a video.

The audio drove the puppet's mouth movement, timing, gestures, and overall performance with very little textual instruction.

At 41:42, Alon explained why audio is such a strong condition: it gives the model temporal information that can be painful to describe in text.

A useful rule is: if your idea starts with a performance, start with the performance.

Record the dialogue if you care about cadence. Feed in the narration if animation must follow an existing track. Use audio when gestures and expression should respond naturally to speech.

LTX's audio-to-video documentation describes the same broader idea: audio can act as a driving signal for synchronized visuals.

Step 6: Lock important visuals with references

Text-to-video is excellent for exploration. Consistency needs more control.

At 26:56, we asked how to make sure the Dalmatian kept the exact same spot pattern across generations.

The answer was to stop relying on text alone.

Easiest: start from an image

If the exact character matters, establish the appearance in an image and use image-to-video. Now the model has a concrete starting point.

Better for sequences: build storyboard frames

At 48:34, Alon recommended using images from the same scene as first frames for each shot.

That gives you a controlled visual plan before motion enters the problem.

Most specialized: train a LoRA

At 39:28, Daniel said a LoRA is the strongest route when one specific character needs to recur across a larger production.

A LoRA is a lightweight fine-tune that teaches the model a specific character, style, or behavior without retraining the whole system.

This is where open weights become strategically important. Studios can adapt the foundation around their own recurring characters, proprietary footage, and production constraints.

Step 7: Treat scripts as a sequence of shots

At 43:19, Corey asked whether LTX can follow a script.

Daniel's short answer was yes.

For dialogue, put the line in quotes and make the speaker clear. Multiple characters are harder because the model needs to assign each voice to the right person at the right time. Daniel said LTX has developed a specialized modality for that case.

He also described a 2.5 component that can choose duration based on the input instead of forcing a fixed clip length. That matters because a model told to fit too much dialogue into too little time will try to obey.

The team's general recommendation at 44:51 was roughly 20 seconds for a normal clip, with longer specialized avatar workflows possible.

For a beginner, the practical workflow looks like this:

1. Break your script into shots.
2. Decide what each shot needs to accomplish.
3. Establish a reference frame when consistency matters.
4. Generate the shot.
5. Assemble the clips on a normal editing timeline.
6. Use generative editing only where the footage needs repair or extension.

That is much more controllable than asking for an entire 60-second scene in one generation.

Step 8: Fix the three bad seconds instead of regenerating the whole video

One of the best demos had nothing to do with creating a scene from scratch.

At 33:29, Alon showed two clips from our podcast with an ugly jump between them.

Editors usually hide that kind of cut with B-roll, a reaction shot, or a transition.

LTX's Retake workflow regenerates a selected region while keeping the surrounding footage intact. In the demo, the model created the missing movement between two Neuron podcast clips and made them look like one continuous take.

Corey immediately saw the podcast use case: a guest gives a great answer, the recording has a bad cut or dropout, and you want to preserve the content without covering half the screen in stock footage.

This is where generative video starts looking less like a novelty and more like normal creative software.

The prompt changes from:

Make me a whole video.

To:

Fix these three seconds.

That second request is narrower, easier to evaluate, and much closer to how professional editors actually work.

Step 9: Fine-tune the repetitive part of your workflow

The professional examples in the stream kept following the same pattern: humans decide what matters; the model handles a repeatable transformation.

At 12:17, Alon described animation partners whose artists create keyframes while a customized LTX setup produces the in-between frames.

For 2D animation, that requires special care because clean lines matter. The model cannot smear one drawing into the next and call it finished.

The team also described VFX companies running customized models on proprietary data, sometimes on premises so footage and IP never leave the studio.

At 38:26, Daniel said the team has seen useful specialized behavior from surprisingly small datasets. He mentioned examples around 10 to 15 clips while stressing that requirements depend heavily on the complexity of the task.

His advice was sensible: start with a small dataset, see what the model learns, then add more data if needed.

That is cheaper and more informative than collecting thousands of clips before proving the training recipe works.

Bonus: why LTX keeps calling this a world model

Video generation was only part of the conversation.

At 47:13, Corey asked how the same underlying model could appear in robotics work.

Daniel's simplified explanation was intuitive.

A video model takes the current visual state and predicts what a plausible future state should look like. If a robot sees an object and needs to put it into a box, a fine-tuned visual model can help represent what the successful action should look like from the robot's point of view.

A separate robotics system still has to translate that visual prediction into actual motor commands. Daniel explicitly said he was simplifying the implementation.

The point is that a model trained to understand how scenes evolve can become useful outside filmmaking. LTX says partners are already experimenting with physical AI, avatars, VFX, and other specialized domains on the same foundation.

What still gets hard

The livestream was full of impressive demos, but the LTX team repeatedly surfaced the limits too.

Prompting still takes iteration. Alon called it a black box and said artists often prefer visual guidance over prose.

Multi-shot generation is harder to control. At 49:46, Daniel said you can prompt multiple scenes directly, but it gets trickier to steer. Storyboards are safer when consistency matters.

Generated captions are unreliable. At 52:11, the team said LTX may attempt text inside the video, but they would not promise reliable open captions from that workflow.

Local generation still depends on hardware. At 53:40, the team said their official preference is generous VRAM, while community users have managed smaller setups through offloading and other compromises.

That is the credible counterpoint to the demos: AI video is becoming easier to direct, while production-grade control still comes from references, fine-tuning, editing, and normal filmmaking discipline.

Your 20-minute LTX-2.5 action plan

If you have never generated AI video before, ignore the advanced workflows for your first session.

1. Open LTX Explore

Go to LTX Explore and start from a pre-populated example.

At 55:56, Daniel said the platform intentionally includes sample prompts and assets because beginners were struggling with where to start.

2. Make one simple shot

Use:

subject + action + environment + camera + lighting + audio

One subject. One clear action. One shot.

3. Generate it

Identify what the model got right.

Then identify the one mistake that matters most.

4. Change one variable

Add the missing direction and generate again.

Repeat until the shot moves toward your intent.

5. Add a reference when words become inefficient

If you are writing a paragraph to describe a pose, recurring character, exact camera path, or vocal performance, use an image, audio clip, video, or keyframe instead.

That was the strongest lesson from the entire livestream: video prompting is becoming the art of choosing the right control signal.

Sometimes that signal is text. Sometimes it is a voice recording. Sometimes it is a storyboard frame. Sometimes it is three seconds of motion you already shot yourself.

The bigger shift is from prompting to directing

Early AI video looked like image prompting with extra vocabulary.

The workflow we saw with LTX-2.5 looks much closer to filmmaking:

You establish the shot. You block the action. You choose the camera. You define the performance. You create a rough take. Then you fix the part that failed.

Text remains useful, but it increasingly sits beside images, audio, keyframes, video references, fine-tunes, and editing controls.

That raises the most interesting unresolved question from the stream: if AI video interfaces keep moving toward multimodal direction, does "video prompting" eventually stop being a distinct skill?

The winning interface may look less like one giant prompt box and more like an infinitely flexible editing timeline where text is simply one control among many.

LTX-2.5 gives us a strong preview of that workflow.

Resources

• Watch the full LTX-2.5 livestream
• Explore LTX-2.5
• Try LTX Explore
• Read LTX's prompting guide
• Read the LTX-2.5 announcement
• Explore the open LTX model on Hugging Face
• Read our previous coverage of LTX 2.3