MAGI-2-preview is heading to SGLang: what the new serving PR reveals

MAGI-2-preview, Sand.ai's 114-billion-parameter mixture-of-experts video-generation model, went open-source on August 5, 2026 — and eleven days later the first sign that it is about to get production-grade serving infrastructure has appeared. On August 16, a pull request opened in the SGLang repository titled [diffusion][Model] Support MAGI-2-preview (sgl-project/sglang, PR #35014), and the title is accurate: it wires native serving support for the model into SGLang's diffusion stack. It is also, as of this writing, still a pull request — open, awaiting code-owner review, with CI checks failing. Nothing has merged, so nothing is servable yet. But for anyone weighing whether MAGI-2-preview can move off Sand.ai's reference Docker-and-torchrun setup and onto a mainstream serving runtime, the PR is a detailed roadmap.

So treat this as a what-we-know-so-far piece, not a release note. The model is real and shipped — that happened August 5, with weights on Hugging Face and code on GitHub under an Apache-2.0 license. What is unverified is the serving work: the SGLang integration is a single open pull request, its details can change in review, and until it lands, SGLang cannot actually run MAGI-2-preview. The value is in what the PR reveals about the model and about the path to running it in a real runtime.

The model the PR is for, in one paragraph

MAGI-2-preview is Sand.ai's attempt to scale video generation the way language models scaled — with a mixture of experts, and it is the successor to the open-source MAGI-1 (a 24B autoregressive video model from April 2025). The new model totals roughly 114B parameters but activates only about 6B per token, using an ultra-fine-grained multi-head MoE: a 3,072-dimensional hidden state is split into twelve 256-dimensional heads, each routing to six of 256 experts, which works out to 3,072 expert units per MoE layer and 72 experts activated per token across 36 layers. It is a unified single-stream audio-video model — text, video, and audio pass through the same transformer and exchange information through self-attention at every layer, instead of through a separate cross-attention pipeline. It does text-to-video and image-to-video, and it generates 10-second clips — the only duration supported — with a synchronized stereo soundtrack generated in the same denoising trajectory and muxed into the output file.

Generation runs in two stages. A magi2_preview stage denoises at 512×896, then a magi2_refiner stage upscales to 1088×1920. The base release uses 100 preview and 5 refiner denoising steps; Sand.ai says a distilled version with far fewer steps is coming. The checkpoint set is a single Hugging Face repo of about 307 GB: the 228 GB preview stage, a Qwen3.5-27B text encoder, the 14 GB refiner, a 5 GB audio VAE, a video VAE borrowed from Wan2.2-TI2V-5B, and a distilled turbo VAE decoder used by default. Hardware requirements are eight NVIDIA Hopper (H100-class) GPUs, with the reference launcher letting you offload the text encoder, preview, refiner, and VAE between CPU and GPU across phases.

On performance, the figures circulating are reported, not independently reproduced. The claims — a VBench score of 86.54%, ahead of Sora 2 (84.37%) and Kling 2.0 (84.20%) in the same Chinese press coverage, and 6th on the Artificial Analysis image-to-video leaderboard with an Elo around 1106 — come from the vendor and the launch coverage, and none of it has had an independent third-party run in the eleven days since release. Sand.ai also quotes inference cost at about 0.5 yuan (roughly $0.07) per 10-second 1080p clip on eight H100s, or about a tenth of mainstream video models. Take all of it as vendor-and-press-reported until someone measures it.

Why a serving pull request is the real news

Until now there has been exactly one supported way to run MAGI-2-preview: Sand.ai's own reference stack, a Docker image plus torchrun, on eight NVIDIA Hopper H100s. That is a workable but bespoke path — you inherit Sand.ai's launcher, its offload decisions, and its opinionated way of staging the text encoder, preview, refiner, and VAE between memory tiers. A pull request adding the model to SGLang matters because SGLang is the serving runtime that a large share of the self-hosted generative-AI world actually deploys in production. First-class support means MAGI-2-preview becomes runnable in a mainstream runtime with SGLang's machinery behind it — Ulysses sequence parallelism, expert parallelism, activation offload, the VAE, the scheduler, and pipeline-stage infrastructure. That is the difference between "I can run it on their stack" and "I can run it on the stack my team already operates."

What the PR actually builds

The integration is built on existing SGLang machinery rather than on the reference torchrun path. The PR adds a multi-head MoE layer, attention-sink plumbing, block-window local attention for the refiner stage, and multi-stream hyper-connections — the architectural pieces of MagiMoE that generic layers do not already express. Around them it reuses SGLang's existing Ulysses sequence parallelism, expert parallelism, offload, VAE, scheduler, and pipeline-stage components. It also ships documentation (a MAGI-2 cookbook page for SGLang's diffusion docs) and 47 GPU-free unit tests, which is a good sign for how much of the model's behavior can be verified without renting eight H100s.

The PR also makes the model's constraints explicit:

• Hardware — eight NVIDIA Hopper H100s, with the reference stack's cpu / gpu / roundtrip offload modes mapping onto where the text encoder, preview, refiner, and VAE sit between phases.

• Parallelism — --num-gpus must divide every head axis, while --tp-size, --ring-degree, and --enable-cfg-parallel are rejected. This is a model with a lot of routing dimensions, and the parallelism layout has to line up with them.

• Outputs — only 1920×1088 and 896×512 resolutions are accepted, and only 10-second clips; torch.compile is not supported.

That last set is worth reading twice if you are planning a deployment: this is a model that, at least in this early integration, is locked to two resolutions and one duration.

What is still unverified

Everything about the serving work. The PR is open, awaiting code-owner reviews, and CI checks were failing as of August 16. A pull request of this size can sit in review for days or weeks; there is no merged state, no release, and no announcement from SGLang. And the model-side claims — the VBench score, the Artificial Analysis rank, the 0.5-yuan cost figure — are vendor- and press-reported, not independently reproduced. If you build a workflow on this PR today, you are building on a roadmap, not a runtime.

What it means for the cost math

The reason MAGI-2-preview drew attention is its economics. A model that activates 6B parameters per token while carrying 114B of capacity is cheap to run per clip — Sand.ai puts the number at about 0.5 yuan per 10-second 1080p clip on eight H100s — and that is the kind of number that decides whether small teams can afford video generation at all. But the 0.5 yuan assumes the reference stack, the H100 cluster, and no serving overhead. The usual way an open model like this becomes broadly usable is through a managed API: someone hosts it, prices per clip, and you do not rent eight H100s.

When a hosted route exists, the routing angle becomes relevant. On a routing platform, whatever list price the vendor sets for a MAGI-2-preview clip is what you pay — OrcaRouter passes provider list prices through at zero markup, so a vendor price cut is live on our side the same day it ships, with no renegotiation. And an eleven-day-old open-weight checkpoint with no independent benchmarks is exactly the kind of model you want behind automatic failover: point a route at it for evaluation, keep a proven fallback on the same endpoint, and the moment the early checkpoint stalls or produces something unusable, the call fails over instead of your pipeline. That is how you try an unproven model without betting a production path on it.

What we're watching now

• Whether the PR merges, and what changes in review. The constraint list — two resolutions, one duration, no torch.compile — may not be final.

• The distilled checkpoint. Sand.ai says fewer-step weights are coming; that is what turns the 0.5-yuan figure from a lab measurement into a realistic per-clip cost.

• First independent benchmarks. The VBench and leaderboard figures are vendor- and press-reported; a third-party run would settle how the 6B-active claim holds up.

• Whether other runtimes follow. SGLang is the first major serving runtime to take MAGI-2-preview; vLLM and others may not be far behind.

• Whether a managed API appears. The model's whole pitch is low cost at scale; the moment a hosted route exists, the pass-through pricing math above goes live.

The honest summary: MAGI-2-preview is an eleven-day-old open model whose cost structure could matter, and the SGLang PR is the clearest signal yet that the ecosystem is taking it seriously. But the serving support is an open pull request, not a shipped capability. Treat the roadmap as real and the runtime as not-yet-there — and when the model does land behind a real API, the failover-first approach is how you adopt it without staking a production path on a checkpoint nobody has independently benchmarked.