LTX-2.5 Released: A Video in 6.8 Seconds

Lightricks officially released LTX-2.5 yesterday (August 11). The most eye-catching figure for this release is that generating a 10-second, 720p video on two NVIDIA GB200 GPUs takes just 6.8 seconds—marking the first time generation has been significantly faster than the video’s own playback duration.

The model is now available through Hugging Face, the hosted LTX API, and ComfyUI. Users can download the weights for self-deployment and fine-tuning, or purchase a generation service billed by the second. Organizations with annual recurring revenue (ARR) below $10 million may use the LTX-2.5 weights commercially for free. Enterprises above that threshold must negotiate a separate commercial license.

The focus of this update is not simply to push visual quality a little higher, but to address the three most practical obstacles to deploying video models: slow generation, difficult workflow integration, and a lack of control over closed-source APIs.

6.8 Seconds Is Fast, but Don’t Overlook the Two GB200s

According to benchmark results published by Lightricks, LTX-2.5 can generate a 10-second, 720p video in 6.8 seconds on two NVIDIA GB200 GPUs. In other words, the model has entered the “real-time factor below 1” range: before one video finishes playing, the next one has already been generated.

This is especially important for bulk ad creative, short-video storyboard previews, and in-game cinematics. Previously, video generation was more like offline rendering, with users waiting tens of seconds or even several minutes after submitting a job. Only when generation time falls below the video’s duration does it become viable for interactive workflows, such as:

• Recomputing a portion of a shot immediately after the user drags the timeline;
• Generating dozens of versions with different copy and characters in a single batch for an advertising team;
• Having games or virtual characters generate the next scene based on real-time input;
• Allowing directors to adjust prompts during a meeting and preview camera movements immediately;
• Enabling e-commerce platforms to convert product images into short videos with sound effects at scale.

However, 6.8 seconds is not a typical result that ordinary developers can reproduce simply by downloading the model.

Two GB200s represent one of the most expensive computing configurations currently available, and the figure was measured after the model had been loaded and the system had entered a steady operating state. It is closer to “ideal data-center throughput” than the end-to-end experience on a single consumer GPU. Steps such as downloading the model, initial compilation, loading the weights, input preprocessing, and video encoding are typically not fully reflected in this figure.

LTX-2.5 claims to run on GPUs with as little as 16GB of VRAM and provides low-memory options such as FP8 and CPU offloading. But “able to run” and “runs quickly” are two different things. Offloading some weights to system memory is like constantly moving large files between VRAM and RAM: it reduces VRAM pressure, but PCIe transfers and CPU wait times slow down generation.

A more accurate interpretation, therefore, is that LTX-2.5 demonstrates the architecture’s potential for faster-than-real-time generation. For now, however, the 6.8-second figure is primarily a showcase of the upper limit achievable on high-end inference clusters, not a universal promise across all deployment environments.

The Hosted API Is Not as Fast, but It Is Already Practical Enough

In tests of LTX’s own hosted service, generating a comparable 1080p video took approximately 23.7 seconds. This is less impressive than the self-hosted 720p result on two GB200s, but it is closer to what developers will actually encounter when calling an online service.

The two figures cannot be compared directly. One involves 720p output, high-end local hardware, and steady-state operation; the other involves a hosted API at a higher resolution and may also include job scheduling, video encoding, and network transfer. Treating 6.8 seconds as the latency of every API request would overstate the actual experience.

In terms of pricing, LTX-2.5 Fast charges $0.09 per second for 720p audio-and-video generation. A 10-second video costs $0.90, or approximately RMB 6.1. It can scale up to 4K at $0.30 per second. A single generation can be up to 20 seconds long, with support for 24 or 25 fps.

LTX-2.5 Pro is priced at $0.12 per second, or approximately $1.20 for 10 seconds. It emphasizes higher-quality output and better text and typography, supporting videos of up to 1080p and 10 seconds.

Judging solely by published prices, LTX-2.5 Fast is not the cheapest option:

| Model | Price per Second | Price for 10 Seconds | Key Features | | --- | ---: | ---: | --- | | Veo 3.1 Lite | $0.05 | $0.50 | Lowest price, but no 4K support or editing extensions | | LTX-2.5 Fast | $0.09 | $0.90 | Open weights, self-hosting and fine-tuning support, up to 20 seconds | | Veo 3.1 Fast | $0.10 | $1.00 | Closed-source API with a relatively affordable path to 4K | | Gemini Omni Flash | $0.10 | $1.00 | Focuses on generation quality and iteration experience, up to 720p | | LTX-2.5 Pro | $0.12 | $1.20 | Greater emphasis on visual quality, text, and typography |

LTX-2.5’s real pricing advantage is not that it is a few cents cheaper per second, but that developers can avoid paying per generation.

For applications with low usage, a hosted API is naturally more convenient. But for platforms that need to generate tens of thousands of videos every day, per-second billing quickly becomes a continuously growing expense. Open weights allow enterprises to purchase or rent GPUs, turning inference costs into relatively predictable infrastructure spending while also enabling their own caching, batch processing, quantization, and model distillation.

Of course, self-hosting is not a free lunch. If GPU utilization remains low over the long term, the cost per video may be higher than using an API. The economics of local deployment become compelling only when request volume is sufficiently high and jobs can be queued and processed in batches.

“Open Weights” Does Not Mean Open Source in the Traditional Sense

LTX-2.5 allows users to download the weights, deploy the model themselves, and fine-tune it using enterprise data and intellectual property. For companies unwilling to upload unreleased advertisements, film and television footage, or user likenesses to a third-party API, this is more important than simply lowering the price.

Users can also run the model locally, on edge devices, or in a private cloud, and generated outputs are not subject to mandatory branded watermarks. This makes it more suitable for film and television production, brand marketing, and internal enterprise content systems, rather than limiting it to a black-box capability available only through the public cloud.

Strictly speaking, however, LTX-2.5 should be described as an “open-weight model,” not unrestricted open-source software.

Free commercial use is limited to organizations with ARR below $10 million, and the revenue calculation covers affiliates and subsidiaries under common control. Organizations above that threshold require a commercial license, which is clearly different from permissive licenses such as Apache 2.0 and MIT. Developers should not assume that simply because the weights are available on Hugging Face, they can be used without restriction in any commercial operation.

This licensing strategy is highly targeted: individual developers, research teams, and most startups can adopt the model at low cost. Once the model enters a large enterprise or becomes part of a high-revenue business, Lightricks can monetize it through commercial licensing. The company sacrifices some of the “pure open-source” narrative in exchange for a clearer path to commercial returns.

Development teams should confirm at least three things before going live:

1. Whether the ARR calculation includes parent companies, subsidiaries, and affiliates;
2. Whether derivative weights produced through fine-tuning may be distributed externally;
3. Whether the necessary rights to generated content, training data, and individuals’ likenesses have been obtained.

Open weights address model controllability; they do not automatically resolve copyright and compliance issues.

Native ComfyUI Integration Matters More Than Providing Weights Alone

LTX-2.5 entered ComfyUI’s native workflow on the day of its release. After updating ComfyUI, developers can build generation pipelines using templates and built-in nodes, without relying on third-party custom nodes from unknown sources.

It should be noted that LTX-2.5 is not the first version to support native ComfyUI integration. LTX-2.3 already supported text-to-video, image-to-video, first-and-last-frame interpolation, audio-driven video, IC-LoRA control, and ID-LoRA personalization. The value of version 2.5 lies in maintaining official native integration while adding multi-shot capabilities on top of its existing synchronized audio-and-video generation.

Multi-shot generation is not simply a matter of stitching together several independent clips. Truly usable multi-shot generation requires the model to understand continuity between shots: characters’ clothing must not suddenly change, props must not jump between positions, and environmental lighting and spatial layouts must remain consistent. For advertisements, music videos, and narrative shorts, this cross-shot consistency is more important than whether any single shot looks spectacular.

ComfyUI is particularly well suited to handling such complex pipelines. Users can connect reference images, depth maps, pose controls, audio, LoRAs, upscaling models, and post-processing frame interpolation in a node graph, then replace only a single step when needed. Compared with repeatedly “rolling the dice” in a web input box, node-based workflows are easier to reproduce, share, and run in batches.

For example, a product-video workflow could be broken down as follows:

• Import the primary product image and lock the subject’s appearance;
• Use a prompt to generate the first showcase shot;
• Control shot transitions using the first and last frames;
• Generate ambient audio or dialogue synchronized with the visuals;
• Apply localized inpainting to key shots;
• Complete the process with upscaling, frame interpolation, and encoded output.

This is also where LTX-2.5 is more attractive than API-only video models. APIs can be integrated into products quickly, but ComfyUI combined with open weights allows creators to enter the model’s generation pipeline and control or replace every step.

Native nodes still have version dependencies, however. Nodes may become available at different times across ComfyUI’s stable, nightly, and cloud versions. If a template is missing nodes or components are absent after importing a workflow, the first step should be to check whether ComfyUI has been updated, rather than immediately installing third-party node packages.

LTX-2.5 Is Really Competing for the “Production Pipeline”

Competition among current video-generation models is no longer limited to visual-quality leaderboards. Closed-source products such as Veo continue to hold advantages in quality, stability, and cloud-service experience, but developers must accept the resolution, duration, moderation policies, and pricing set by the vendor. Open-weight models, on the other hand, offer greater control but often require complex deployment, while generation speed and audio-video synchronization tend to lag behind.

LTX-2.5’s strategy is to narrow the gap between the two as much as possible:

• Use the 6.8-second result on two GB200s to prove that the model can generate faster than real time;
• Use a hosted API to lower the barrier to initial integration;
• Provide Hugging Face weights to meet private-deployment and fine-tuning requirements;
• Enter creators’ existing workflows through native ComfyUI nodes;
• Reduce post-production stitching costs through native audio-video and multi-shot capabilities.

This combination is more pragmatic than simply announcing a certain improvement in visual quality. When enterprises adopt video models, whether they can actually deploy them is usually determined not by a single benchmark table, but by whether latency, cost, deployment options, licensing, and workflow integration all meet requirements at the same time.

LTX-2.5 still has clear limitations. The 6.8-second result depends on extremely high-end hardware; the real-world speed of the 16GB VRAM configuration requires more independent testing; the open-weight license includes a revenue threshold; and its claimed multi-shot consistency must still be tested with complex characters, long-duration motion, and shot transitions.

But it at least offers a direction more valuable than “another closed-source video API”: a model must not only be able to generate content, but also be deployable, modifiable, and genuinely embeddable in production pipelines.

For individual developers and small to medium-sized teams, the most sensible approach is to first validate results using the hosted service or ComfyUI templates, then decide whether to self-host based on usage volume. Do not take on GPU operations costs too early merely to save a few cents per second. Likewise, do not overlook future costs and data risks as usage scales simply because an API is easy to integrate.

What makes LTX-2.5 most noteworthy is not the 6.8-second headline figure itself, but that open weights, a hosted API, and native workflow integration have finally been brought together in a single product. This kind of completeness is exactly what video models need to evolve from demonstration tools into production infrastructure.

References

• ITHome: LTX-2.5 Model Debuts, Generating a 10-Second 720p Video in Just 6.8 Seconds — Includes the release date, performance data, API pricing, and licensing threshold.
• Hugging Face: Lightricks/LTX-2.5 Model Page — Provides model weights, low-VRAM deployment recommendations, documentation for Python inference tools, and a link to the full license.