Skip to main content
LongLive-2.0 is an autoregressive, real-time video model built for multi-shot generation: a single session moves through many scenes without ever tearing down the stream. Set an opening shot, then steer with soft shot transitions and hard cuts, sent live or scheduled in advance. The LongLive-2.0 reference is split across four pages: this overview, the complete command and event schema, the prompt guide for writing prompts and composing multi-shot sequences, and an end-to-end tutorial against the open-source reference frontend. The base wire protocol is the same as every other Reactor model: open a session with the Reactor class (model name longlive-v2), send named commands, and receive events. LongLive-2.0’s surface adds commands for shots, cuts, scheduling, changing the seed, and playback control. Generation is text-driven, there is no reference-image input in this release.

​
At a glance

SpecValue
Model namelonglive-v2
Pricing
Resolution1280 × 704
Frame rate24 fps
Chunk size29 frames (~1.2s)
Scene limit48 chunks (~58s) per scene
Transitionsshots (soft) · cuts (hard)
InputText only (no reference image)
The model name is the string you pass when you open a session, e.g. new Reactor({ modelName: "longlive-v2" }). See Pricing & Billing for how billing works.

​
Key features

Multi-shot generation

One continuous session spanning many scenes: change shots and cut to new scenes without reconnecting.

Soft shots & hard cuts

A soft set_shot keeps the world and continuity; a hard scene_cut breaks cleanly to a new scene.

Storyboard scheduling

Schedule shots and cuts at exact chunk indices to compose a whole sequence before you press start.

​
Chunks, scenes, and length

LongLive-2.0 generates video one chunk at a time. A chunk is 29 frames, about 1.2 seconds at 24fps. Every chunk_complete event carries two counters that track your position:
  • chunk_index: chunks since the current scene began. Resets to 0 on every scene_cut.
  • session_chunk: cumulative chunks since start. Never resets. This is the clock that scheduled prompts fire against.
Each scene can run for up to 48 chunks (~58 seconds), after which it completes on its own. That limit is per scene, not per session, which is what lets you control total length:
  • A scene_cut ends the current scene and starts a fresh one with a new 48-chunk budget, so cuts are how you extend a video. A session that keeps cutting can run indefinitely; one that never cuts stops at ~58 seconds.
  • A set_shot stays in the current scene (keeping its memory) and spends from the same budget. Use it to evolve a scene, not to lengthen it.
To make a video longer, cut to a new scene; to evolve a scene in place, send a shot. A prompt scheduled past its scene’s 48-chunk ceiling never fires, so cut before you reach it.

​
Quick start

The fastest path to a working LongLive-2.0 app is the create-reactor-app CLI, which scaffolds a runnable project. You can also clone the open-source reference frontend directly, or follow the tutorial for a guided walkthrough. 
npx create-reactor-app my-longlive-app --model=longlive-v2
A minimal connect-and-generate flow looks like: 
import { Reactor } from "@reactor-team/js-sdk";

const video = document.querySelector("video")!;
const reactor = new Reactor({ modelName: "longlive-v2" });

// Render frames as soon as they arrive.
reactor.on("trackReceived", (name, track, stream) => {
  if (name !== "main_video") return;
  video.srcObject = stream;
  void video.play();
});

// Once the session is ready, open a shot and start generating.
reactor.on("statusChanged", async (status) => {
  if (status !== "ready") return;
  await reactor.sendCommand("set_shot", {
    prompt: "A lighthouse on a cliff at dusk, waves crashing below",
  });
  await reactor.sendCommand("start", {});
});

const jwt = await getToken(); // token minted on your server
await reactor.connect(jwt);
LongLive-2.0 also has a typed SDK, @reactor-models/longlive-v2, with named methods (setShot, sceneCut, start, …) and React hooks. See Typed Model SDKs.

​
How it works

On connect the model is live but idle. Set an opening shot with set_shot, call start, and frames begin streaming on the main_video track. From there you drive the session in real time: send a set_shot or scene_cut to transition at the next chunk boundary, schedule_shot / schedule_scene_cut to plant prompts ahead, pause / resume between chunks, and reset to clear everything and begin a new sequence. See the schema for every command and event, and the prompt guide for how to compose multi-shot sequences.