Decart's Lucy 2.5 Transforms Live Video at 30 FPS Without Drifting

Lucy 2.5 is Decart's latest upgrade to its live video transformation model, and it pushes the boundary of what "real-time" means for generative video. It delivers higher-quality edits, physically-aware VFX, stronger temporal consistency, and even lower latency, all generated live at 30 FPS. This is not a clip generator. Every single frame is synthesized on the fly, responding to motion, lighting, and the scene as it evolves.

The Problem With Every Other Video AI

Most generative video tools work like a batch job: you submit a prompt, wait, and get a clip back. That model breaks the moment you need the output to respond to something happening right now. This represents a fundamental shift in how AI handles video: from static artifact generation to dynamic, mutable streaming. The deeper problem is that even systems that attempt continuous generation tend to drift. Small errors compound frame by frame until the subject's face morphs, the costume dissolves, or the scene collapses entirely.

Using Smart History Augmentation, the model can run continuously for hours without identity collapse or quality degradation, unlike competing models that typically maintain coherence for only 60 seconds. Lucy 2.5 extends this further with a new mechanism called Self-Anchoring, which is the headline technical innovation in this release.

Self-Anchoring: The Edit That Doesn't Drift

Self-Anchoring solves a fundamental problem in autoregressive generation (where each frame is generated conditioned on previous frames). Over time, the reference signal that guides the edit diverges from what the model is actually producing, causing the edit to slowly fade or mutate. Lucy 2.5 fixes this by having the model adopt a snapshot of its own generated output as the new reference anchor, rather than relying on the original input frame.

The key insight is not just using self-generated output at inference time, but training the model under those same self-anchored conditions. This means the model learns to actively exploit its own output as a guide, not just tolerate it. The results are significant:

• Edits persist over time: A character swap or costume change made in the first seconds of a stream stays locked in minutes later.
• Identity survives motion: Subjects can leave frame, turn around, and return without the edit dissolving.
• Stability compounds: Combined with Smart History Augmentation, streams hold identity, geometry, and texture over dramatically longer horizons.

Better Edits, Built on Synthetic Data

Improving edit quality at this scale required training data that simply does not exist organically. Decart engineered a massive synthetic corpus of video editing pairs. The pipeline starts with high-quality image-to-image transformations, then uses internally trained models to propagate those static edits across full video sequences, producing temporally consistent video editing pairs at scale.

They also introduced a coarse-to-fine prompting hierarchy. You can give a simple high-level instruction like "make the background a neon cyberpunk city" and the model handles the rest, or you can drill down into fine-grained details about position, style, color, and size. This is paired with prompt alignment to generic scene descriptions, which the team says enables deeper emergent generalization rather than rigid instruction-following.

What this unlocks in practice:

• Physically-aware VFX: Elements like flowing water, fire, shifting sand, and viscous slime now interact naturally with the environment rather than floating on top of it.
• Global scene re-theming: The entire aesthetic of a video can be transformed, such as shifting a sunny city street into a cyberpunk dystopia, while preserving the underlying structure, geometry, and identity of subjects.
• Volumetrically-aware object swaps: When replacing one object with another, the model understands the original 3D space, matching contact points, shadows, and physical interactions.
• Clean object removal: When an element is erased, the model reconstructs the newly exposed background geometry consistently over time.

The Inference Stack Keeping It All at 30 FPS

Better model quality means more compute per frame, which means the inference stack has to work harder to stay real-time. Decart made three key optimizations to keep latency down:

1. Low-precision quantization: Custom quantization techniques run inference in MXFP8 and NVFP4 (very low bit-width number formats with native GPU hardware support), unlocking up to 4x speedups on compute-bound operations.
2. Dynamic sparse attention: Attention (the mechanism that lets the model relate every part of the frame to every other part) dominates the Transformer's forward pass. A custom sparse attention algorithm dynamically identifies redundant computations in each attention call and prunes them with no loss in accuracy.
3. Deeper kernel fusion: More aggressive fusions and improved megakernels reduce the overhead of launching GPU operations and minimize costly memory reads, which are critical bottlenecks in low-latency inference.

With its sub-40 millisecond latency, Decart says it's possible to implement these effects in the blink of an eye. That number matters because it keeps edits feeling instantaneous to a live audience, not like a filter catching up.

What It's Actually Good For

Decart has already been testing Lucy-based systems with Twitch creators, where latency tolerance is effectively zero. At TwitchCon, the company demonstrated real-time character swaps, wardrobe changes, and environmental transformations that responded instantly to a streamer's movement and audience prompts, all running inside standard live production workflows.

The practical use cases cluster around a few high-value verticals:

• Live streaming: Streamers can let audiences vote on scene transformations, character skins, or VFX in real time.
• Virtual try-on: By sharing their camera, users can see new items in context and try before they buy, with the AI adjusting attributes such as color, texture, and lighting in real time so it updates flawlessly as they move around.
• Dynamic advertising: Brands can transform video streams into a fluid and programmable tapestry for advertising an array of products, injecting and swapping out various items within a scene, based on regional data or viewer demographics.
• Robotics training data: A single real-world demonstration can be expanded into thousands of plausible variations with different textures, lighting conditions, object geometries, and backgrounds, while preserving physical consistency.

Limitations Worth Knowing

The compute cost is real. According to Decart's API pricing for real-time video editing, the cost is approximately $0.05 per second. A three-minute live try-on session runs to roughly $9, which is hard to justify at consumer scale today. The model's higher hardware requirements, deployment cost, and complexity may limit its application in certain scenarios. The model also currently operates at 720p through the API, not the 1080p cited in marketing materials, which is worth noting for production use cases.

How to Use It

Known for pioneering real-time generative AI video technology, Decart has launched the latest version of its Lucy model, available now through the Decart API. New accounts receive free credits so you can test the API before paying.

Pricing from the official docs breaks down as follows:

Connecting a live camera stream via the Decart API platform takes only a few lines using their JavaScript SDK:

import { createDecartClient, models } from "@decartai/sdk";
const model = models.realtime("lucy-2.5");
const stream = await navigator.mediaDevices.getUserMedia({
  video: { frameRate: model.fps, width: model.width, height: model.height }
});
const client = createDecartClient({ apiKey: "your-api-key" });
const realtimeClient = await client.realtime.connect(stream, {
  model,
  mirror: "auto",
  onRemoteStream: (editedStream) => {
    document.querySelector("#output").srcObject = editedStream;
  }
});
// Apply an edit atomically (prompt + reference image)
await realtimeClient.set({
  prompt: "A person wearing a superhero costume",
  enhance: true,
  image: "https://example.com/reference.png",
});
// Update the prompt live mid-stream
await realtimeClient.set({ prompt: "Add sunglasses to the person" });

The Bigger Picture

Decart is an Israeli real-time generative AI startup backed by Sequoia Capital and Benchmark. The company has raised more than $150 million and is valued at over $3 billion. Their bet is that the next frontier of generative video is not cinematic quality on demand, but persistent, always-on generation that responds to the world in real time.

The field has largely treated video generation as a rendering problem: how do you produce the most beautiful clip from a prompt? Lucy 2.5 reframes it as a streaming problem: how do you keep a generated world coherent and editable indefinitely? Self-Anchoring and Smart History Augmentation are direct answers to that question, and they represent a class of technique that offline generators like Sora or Runway simply do not need to solve. As real-time generation matures, expect these stability mechanisms to become a standard part of the architecture conversation.