Genmo's Mochi 1: An Open 10B-Parameter Video Model Under Apache 2.0

Open video models have long lagged behind closed services such as Sora, Runway and Kling. Mochi 1 from Genmo narrows that gap: 10B parameters, an Apache 2.0 license, and public weights and code. In its blog, RunPod looked at how the model differs from its competitors and how to run it on rented GPUs.

What's inside Mochi 1

Mochi 1 is built on a diffusion architecture called Asymmetric Diffusion Transformer (AsymmDiT). The asymmetry lies in how parameters are distributed: the visual stream gets roughly four times more capacity than the text stream. The logic is straightforward. Video is harder to model than a text prompt, so most of the compute budget goes to pixels and motion.

Prompts are encoded by a single language model, T5-XXL, rather than a set of several encoders. This simplifies the pipeline and reduces memory use. Attention is fully three-dimensional, meaning it accounts for both space and time. Compression is handled by Genmo's own video encoder, AsymmVAE. According to Genmo, it shrinks video by 128x in data volume: 8×8 spatially and 6× temporally, into a latent space with 12 channels.

• Parameters: 10B, diffusion transformer
• License: Apache 2.0, allows commercial use
• Resolution: 480p
• Frame rate: 30 frames per second
• Clip length: up to 162 frames, about 5.4 seconds
• Text encoder: T5-XXL

What's new in v1 and where it falls short

Genmo is betting on two qualities: prompt adherence and smooth motion. The studio says the model handles the physics of fluids, hair and fur well, and "drifts" noticeably less in dynamic scenes. These assessments come from the developer itself, so independent comparisons should be checked separately.

The limitations are also known. A resolution of 480p is too low for production. The model works better with photorealistic scenes and handles animation less well. Fast motion can produce distortions. Genmo has promised a higher-performance version, Mochi 1 HD, but that is a separate release.

Hardware is a separate question. The original recommendations called for several H100-class GPUs, roughly four. The community later built optimized pipelines, for example in ComfyUI, that fit into significantly less VRAM. Exact figures depend on resolution, clip length and quantization, so you need to test on your own configuration.

How to run it in the cloud

RunPod offers a route that requires no hardware purchase. You rent an instance with the GPUs you need, set up the environment and run inference with the open weights. You pay for runtime rather than a subscription. For studios and developers who need video generation only occasionally, this is cheaper than a dedicated server. For constant workloads, it is better to redo the math.

The practical order of steps is as follows:

• Check the Apache 2.0 license: it permits commercial use but does not remove responsibility for the generated content.
• Start with a short clip and a single card, and measure speed and memory consumption.
• If memory runs short, try community builds with quantization and VAE tiling.
• For anything above 480p, plan on upscaling with a separate model.

What matters about Mochi 1 is not record-setting quality but accessibility. A team that needs control over its data, fine-tuning, and independence from a closed API now has a workable base for video experiments. What remains is to test it on your own scenarios.