LingBot-World-Infinity の紹介：エージェント型ハネスを備えたオープンな因果的世界モデル

Robbyant, Ant Group’s embodied-intelligence unit, has released LingBot-World-Infinity (LingBot-World 2.0). It is a causal video generation model that behaves as an interactive world simulator. It is how the team attacks two failure modes: long-horizon drift and interactive latency.

What is LingBot-World-Infinity?

An interactive world model generates video frame by frame, conditioned on a stream of user actions. Each state depends only on past frames and current input. The research team formalizes this as a causal factorization:

Copy CodeCopiedUse a different Browser

p_θ(x_1:T | a_1:T) = Π_t p_θ(x_t | x_<t, a_≤t)

Here x_t is the visual state at time t. The action a_t combines a camera pose and a text prompt. Camera pose uses Plücker embeddings, injected through adaptive layer normalization (AdaLN). Text enters as chunk-wise prompts through cross-attention.

The research team claims four upgrades over LingBot-World:

An unbounded interaction horizon with consistent output quality.

A distilled real-time variant sufficient to drive 720p video streams at 60 fps.

A broader action space, including attacking, archery, spell-casting, and shooting.

An agentic harness pairing a pilot agent with a director agent.

The primary model is 14B. A lightweight 1.3B counterpart is described as deployable on a single GPU.

The Architecture: MoBA and Two-Stage Training

The core contribution is the Mixture of Bidirectional and Autoregressive (MoBA) Attention Mask. It explains the drift.

Standard autoregressive video training uses a teacher forcing mask. Each noisy frame attends to itself and its clean context. The research team found a failure here. As context grows, the model leans on that context instead of predicting future frames. The result is overfitting and visual quality degradation.

MoBA appends a bidirectional full-attention block to the teacher forcing mask. That block acts as a regularizer. It also helps the model handle flexible-length generation.

The cross-attention mask mirrors the split. The autoregressive component attends to a background prompt along with chunk-wise prompts in a lower-triangular pattern. That prevents future semantics from leaking backward. The bidirectional component attends to one global prompt.

Pre-training optimizes a conditional flow-matching objective with rectified-flow interpolation. Post-training then compresses the multi-step teacher into a few-step student:

Consistency distillation: Latents on the same teacher probability-flow ODE (PF-ODE) trajectory must map to identical predictions.

Distribution matching distillation (DMD): The generator follows the KL gradient between noised student and noised data distributions.

The important detail sits in the DMD. The research team applies it over long self-rollout trajectories, not only teacher-forced states. The student is therefore optimized on the state distribution its own predictions induce. That is the stated mechanism behind anti-drift.

The Agentic Harness: The Feature Worth Taking Seriously

A frame predictor does not play itself. The Robbyant research team wraps the generator in a Director-Pilot Co-Simulation Framework.

As described in the research paper, a Vision-Language Model is the Director. It governs macroscopic semantic rules and causal reasoning. The Diffusion Transformer video generator is the Pilot. It simulates low-level physical dynamics and renders transitions.

The harness exposes two interaction modes:

Mode A: Direct Semantic Interaction. The VLM reads the current frame and generates event cards. No object masks are required.

Mode B: Tracking-Assisted Object Interaction. A SAM-based (Segment Anything Model) action-proposal loop tracks objects across chunks. Users select a tracked object and trigger actions. The research paper shows door-opening and ball-rotating rollouts.

Users can also intervene textually. Global state shifts change time of day or weather. Local entity injection spawns creatures, and the VLM picks plausible entry points.

The interface follows game conventions. WASD drives movement, IJKL controls view. Space triggers a jump; P triggers a wing glide. Keys U and O carry VLM-proposed character actions. Keys F and G carry environmental events. Numeric keys are user-registered event slots.

Hands-On: What Ships and What Doesn’t

Expectations need calibration here.

The codebase is built on Wan2.2. Only lingbot-world-v2-14b-causal-fast is downloadable today. The causal-pretrained 14B, the bidirectional 14B, and both 1.3B variants are marked TODO.

Copy CodeCopiedUse a different Browser

git clone https://github.com/robbyant/lingbot-world-v2.git

cd lingbot-world-v2

pip install -r requirements.txt # torch >= 2.4.0

pip install flash-attn --no-build-isolation

huggingface-cli download robbyant/lingbot-world-v2-14b-causal-fast \

--local-dir ./lingbot-world-v2-14b-causal-fast

The provided generate.py runs causal inference with KV caching. It processes frames chunk-by-chunk rather than all at once. The reference command is eight-GPU and 480P:

Copy CodeCopiedUse a different Browser

torchrun --nproc_per_node=8 generate.py \

--task i2v-A14B --size 480*832 \

--ckpt_dir lingbot-world-v2-14b-causal-fast \

--image examples/03/image.jpg --action_path examples/03 \

--dit_fsdp --t5_fsdp --ulysses_size 8 \

--frame_num 361 --local_attn_size 18 --sink_size 6 \

--prompt "A serene lakeside scene with a lone tree standing in calm water..."

The released reference script is 480×832 across eight GPUs. The 60 fps figure describes the deployed stream, which passes a spatio-temporal refiner. That refiner upsamples decoded frames, then synthesizes intermediate frames for a higher frame rate. Both stages compile into TensorRT engines.

A Diffusers checkpoint also exists:

Copy CodeCopiedUse a different Browser

import torch

from diffusers import DiffusionPipeline

from diffusers.utils import load_image, export_to_video

pipe = DiffusionPipeline.from_pretrained(

"robbyant/lingbot-world-v2-14b-causal-fast",

dtype=torch.bfloat16, device_map="cuda")

frames = pipe(image=load_image("seed.png"), prompt="...").frames[0]

export_to_video(frames, "output.mp4")

For a hosted path, Reactor serves the model as reactor/lingbot-world-2. Its docs list 48 fps at 1664×960. Sessions are command-driven and stateful:

Copy CodeCopiedUse a different Browser

from reactor_sdk import Reactor, ReactorStatus

reactor = Reactor(model_name="reactor/lingbot-world-2", api_key=KEY)

@reactor.on_status(ReactorStatus.READY)

async def on_ready(status):

ref = await reactor.upload_file("seed.jpg")

await reactor.send_command("set_image", {"image": ref})

await reactor.send_command("set_prompt", {"prompt": "A misty alpine valley."})

await reactor.send_command("start", {})

Movement is persistent state, not a pulse. set_move_longitudinal: “forward” drives until you send “idle”. Commands land at the next chunk boundary.

Comparison

The research paper’s comparison is qualitative. Every superiority claim rests on side-by-side frame grids.

PropertyM-G 3.0D-WLingBot-WorldHappyOysterGenie 3LingBot-World-Infinity

Generation durationMinutesMinutesMinutesMinutesMinutesHours (Infinite)

Semantic interactionNoneNoneNoneFewFewInfinite

DomainGameGeneralGeneralGeneralGeneralGeneral

Dynamic degreeMediumMediumHighMediumMediumHigh

Real-timeYesYesYesYesYesYes

Open-sourceYesYesYesNoNoYes

Use Cases

Game and level prototyping: Seed an image of a canal town. Hot-swap the prompt to summon a snowstorm. Iterate on mood before any asset pipeline exists.

Embodied simulation: Generate first-person rollouts under scripted camera poses. Feed frames to a policy learner without authoring an Unreal Engine scene.

Synthetic data for video understanding: Chunk-wise prompts produce temporally localized events. Each chunk carries its own caption by construction.

Agent evaluation harnesses: Let the Director agent propose events, then score how a downstream agent reacts. The paper’s own analogy is a coding scaffold such as Codex.

Previsualization: Drive set_camera_pose for directed agent camera moves. Restyle the world mid-stream without losing the reference image.

Key Takeaways

LingBot-World-Infinity (LingBot-World 2.0) is Robbyant’s open causal world model, released with one 14B checkpoint.

MoBA attention plus DMD over self-rollout is the real contribution — it targets long-horizon drift directly.

A Director (VLM) and Pilot (DiT generator) harness turns the frame predictor into an interactive simulator.

The 720p/60 fps headline needs the unreleased deployment stack; the public script runs 480×832 on eight GPUs.

Comparison is qualitative: one 60-minute rollout, no VBench or FVD, and a non-commercial CC BY-NC-SA 4.0 license.

Interactive Explainer

(function(){

var f = document.getElementById('mtp-lbwi-frame');

window.addEventListener('message', function(e){

if(!e.data || e.data.type !== 'lbwi-height') return;

if(f.contentWindow !== e.source) return;

var h = parseInt(e.data.height, 10);

if(h > 200 && h

Check out the Paper, GitHub Repo,  Project Page and Model Weights. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.

Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us

Note:Thanks to the Ant Research team for the thought leadership/ Resources for this article. Ant Research team has supported this content/article for promotion.

The post Meet LingBot-World-Infinity: An Open Causal World Model With An Agentic Harness appeared first on MarkTechPost.