invoker-render-1.0 Video Generation Model: File List

invoker-render-1.0 Video Generation Model: File List

Sample outputs are available on the model card.

At a Glance

Item Value
Repository inclusionAI/invoker-render-1.0
Publisher guide inclusionAI (Ant Group): models and licenses
Published 2026-11-16
License apache-2.0-and-cc-by-nc-4.0
Formats safetensors
Paper arXiv:2611.22925
Source type Primary source (the publisher itself)

Values determined by this site’s code when the information was collected. Dates are JST.

Overview

inclusionAI has released the weights for “Invoker-Render" (invoker-render-1.0), a video generation model that renders high-quality videos taking proxy videos, reference images, and text prompts as inputs. This model is a causal streaming Diffusion Transformer (Causal Streaming DiT) developed based on the research paper titled “Code World Model 2.0: Towards Infinite Controllable Video Generation".

Invoker-Render handles appearance generation itself, while the upstream engine maintains world states such as camera paths, scene layouts, and object motion as structural proxies. It takes a single 1344×768 RGB initial image (appearance reference image), a 24 FPS proxy video, and text instructions as inputs, outputting controlled continuous video through a four-step causal streaming inference.

Specifications

The model specifications listed in the published materials and model card are as follows:

  • Parameter count: 33.12B (approximately 33.1 billion parameters). The main weights directly under the repository are saved in FP32 format without quantization.
  • Architecture: Adopts a causal streaming DiT (Causal Streaming DiT). The architecture identifier in the configuration file (config.json) is MiniMaxH3Transformer3DModel.
  • Input specifications: Accepts a single 1344×768 RGB initial image, a 24 FPS structural proxy video, and text prompts. When running file inference, proxy video frames of 17*N+5 (minimum 39 frames) are required. Note that 24 FPS is the frame rate of the generated video’s timeline and does not indicate the throughput of the inference process itself.
  • Step count: Supports streaming generation via causal four-step (four-step).
  • Control proxy representation: Allows input of control information across various granularities, from coarse layouts to detailed joint geometry, such as semantic maps, sparse 3D bounding boxes, subject masks, shaded geometry, and boxes with skeletons.
  • Included weights: In addition to the main causal weights directly under the repository, LoRA weights for a bidirectional teacher model based on MiniMax-H3 (bidirectional_lora/teacher-live.safetensors) are included. However, this is a separate model from the causal weights directly under the repository and applying them together is not recommended.
  • License terms: The license notation on the model card is listed as apache-2.0-and-cc-by-nc-4.0. Detailed conditions, such as the feasibility of commercial use, require checking the respective license terms of the distributor.

Performance and Quality

Regarding the performance and generation quality of Invoker-Render, validation results are reported in the concurrently published paper “Code World Model 2.0".

Training utilizes an aligned multi-granularity corpus of approximately 200 hours. The training methodology introduces “Progressive Forcing (ProForcing)", where a causal predictor is first trained, then distilled into a 4-step renderer using the training video history, and finally transitioned to self-generated rollouts. This configuration achieves step count compression and suppresses quality drift (degradation) associated with long-duration rollouts.

Experiments in the paper demonstrate that flexible control is possible across diverse proxy types, granularities, and camera paths, with consistent performance improvements confirmed compared to recent streaming baseline methods. Furthermore, by combining fixed appearance anchors and bounded history windows, sessions can be sustained as long as proxy frames continue to be input, demonstrating the ability to stably generate rollout racing videos lasting up to 30 minutes while preserving the appearance of scenes and subjects.

Strengths and Use Cases

Invoker-Render specializes in receiving world states managed by upstream simulators or game engines and rendering appearances (such as textures and lighting) in high quality. Operating like a renderer in a 3D graphics pipeline, a major feature is its ability to completely decouple spatial geometric structure and camera movement from texture and character appearance expression.

Specifically, it proves its true value in expressions and tasks such as the following:

  • Control based on diverse geometric proxies: Accepts proxies of a wide range of granularities, from coarse layouts to precise joint structures, such as semantic maps, coarse 3D bounding boxes, subject masks, shaded geometry, and boxes with joint skeletons (skeletons). Depending on the level of detail in the proxy, it can generate videos that accurately reflect geometric constraints.
  • Long-duration streaming video generation: By maintaining a fixed appearance anchor image and a bounded history window, rendering can be continued without interrupting the session as long as proxy frames continue to be input. The paper shows that even in self-generated rollouts of racing videos lasting up to 30 minutes, the appearance of the scene and subjects is maintained without degradation.
  • Interactive world model construction: Combined with an upstream physical engine or code-based world model, it is suitable for building real-time interactive sessions that instantly vectorize camera paths and object movements responding to real-time user operations and visualize them with 4-step streaming inference.
  • Offline video production and clip creation: It can be used not only for real-time interactive purposes but also as a rendering pipeline to export high-quality finished video based on pre-designed camera work and character layout animation.

Distributed Files

Weight files published in inclusionAI/invoker-render-1.0, listed by this site from the Hugging Face API. Sizes are the actual file sizes.

File Size
bidirectional_lora/teacher-live.safetensors 2.48GB
diffusion_pytorch_model-*-of-00029.safetensors 132.49GB (29 split files)

How to Get It

Invoker-Render weights are available in the Hugging Face repository (inclusionAI/invoker-render-1.0) and have no gated access restrictions, allowing users to download them directly after reviewing the terms of use.

The structure of the distributed weights is as follows:

  • The main weights of the causal streaming DiT are stored directly under the repository in FP32 precision safetensors format (the shard index file is diffusion_pytorch_model.safetensors.index.json).
  • The subdirectory bidirectional_lora/teacher-live.safetensors contains the LoRA weights for a bidirectional teacher model based on MiniMax-H3. Since this is for a different model than the causal weights directly under the repository, users are cautioned not to apply them on top of the main causal weights.
  • This repository contains only the DiT weights of the model itself and does not include VAE, Qwen, causal decoders, silence tensors, and inference bundles. Execution requires preparing corresponding various assets separately.

To run inference, use the official companion repository CodeWorldModel. This codebase is built on top of MiniMax-H3, SGLang, and SGLang-Omni.

The installation and execution steps follow this flow:

  1. Obtain the CodeWorldModel repository and set up the inference environment following the guidance in the included README.md and docs/INFERENCE.md.
  2. Prepare separately required external assets such as VAE and text encoders to configure the inference bundle.
  3. Run the invoker_render.py script to perform batch generation from proxy video files, or start a WebSocket session service to begin interactive rendering.

The included inference code provides browser clients, file clients, and session services via WebSocket connections. The default production profile assumes a multi-GPU configuration using 8 NVIDIA GPUs per node. When running inference, it is necessary to provide a 1344×768 RGB initial image, a 24 FPS proxy video, and text instructions as inputs. Please note that when performing file inference, the number of proxy video frames must satisfy the condition 17*N+5 (minimum 39 frames).

Can You Run It Locally?

The publisher distributes this model as safetensors.

License — apache-2.0-and-cc-by-nc-4.0: A custom license from the publisher. Check the original terms directly, including whether commercial use is permitted.

Compiled by this site’s code from the published formats and the license field. License summaries are not legal advice — check the publisher’s original terms before relying on them.

Our Own Measurements

Measurements We Did Not Take

We have not confirmed that this site meets the commercial-use terms of this model’s license (apache-2.0-and-cc-by-nc-4.0). Because this site carries advertising, we did not run the model (no CPU run, answers, quantization comparison, conversion or generation).

Related Articles

What to Read Next

Sources