Skip to main content
LingBot is a real-time, navigable video model. It takes a seed image plus a text prompt as visual and stylistic anchors, then continuously generates a video stream you walk through with WASD and look around with arrow keys. LingBot produces an infinite, interactive stream that responds to commands frame-to-frame. The LingBot reference is split across four pages: this overview, the complete command and event schema, the prompt guide for writing prompts that steer the world without leaking camera instructions, 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 lingbot), send named commands, receive events. LingBot’s surface adds commands for the prompt, the seed image, WASD movement, the look axes, the seed, and playback control.

​
At a glance

SpecValue
Model namelingbot
Pricing
Throughput16 fps
Latency< 1 second
Resolution1664 × 960
The model name is the string you pass when you open a session, e.g. new Reactor({ modelName: "lingbot" }). See Pricing & Billing for how billing works.

​
Key features

Interactive WASD navigation

Drive the camera through a generated world with movement and look commands that apply at the next chunk boundary.

Image-anchored generation

A seed image fixes the visual identity of the world; the prompt steers the rest.

Live prompt swapping

Re-fire set_prompt at any time mid-generation to swap atmosphere, lighting, or events without restarting the session.

​
Quick Start

The fastest path to a working LingBot app is the create-reactor-app CLI, which scaffolds a runnable project for you. You can also clone the open-source reference frontend directly, or follow the tutorial for a guided walkthrough. 
npx create-reactor-app my-lingbot-app --model=lingbot
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: "lingbot" });

// 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, set a seed image and prompt, then start.
reactor.on("statusChanged", async (status) => {
  if (status !== "ready") return;
  const ref = await reactor.uploadFile(seedImageFile);
  await reactor.sendCommand("set_image", { image: ref });
  await reactor.sendCommand("set_prompt", {
    prompt: "A misty old-growth forest, soft morning light filtering through the canopy.",
  });
  await reactor.sendCommand("start", {});
});

const jwt = await getToken(); // token minted on your server
await reactor.connect(jwt);
That uses the base SDK. LingBot also has a typed SDK, @reactor-models/lingbot, with named methods (setImage, setPrompt, start, …) and React hooks; the tutorial uses it. See Typed Model SDKs.
For a clean first frame, wait for the image_accepted event between set_image and start; otherwise the first chunk renders before the seed image lands and the scene corrects itself one chunk later. The tutorial shows the pattern.

​
How it works

On connect the model is live but idle; it won’t produce frames until it has both a seed image and a prompt and you call start. The workflow:
  1. Connect to the model.
  2. Upload and set a seed image with set_image; it anchors the visual identity of the world (required).
  3. Set a prompt with set_prompt to steer atmosphere and content (required).
  4. Start generation. start fails with a command_error until both an image and a prompt are set.
  5. Drive the camera with the movement and look setters (WASD + arrow keys).
  6. Pause / resume between chunks, or reset to clear state and re-stage with new conditions.
LingBot generates video one chunk at a time, and movement and look are persistent state, not pulses: set_movement: "forward" keeps walking until you send "idle". Commands take effect at the next chunk boundary, so a quick key tap released before the boundary may never visibly land. See the schema for the full command and event surface.