Slop TVNewsLatest
Explainers

PAN 2 runs natively in ComfyUI with no custom node

MBZUAI's 29B world model loads through ComfyUI's built-in loaders after PR #17755 merged on November 15, with an int8 build that samples at 15.2 seconds a step.

Illustration: PAN 2 runs natively in ComfyUI with no custom node
Illustration: SLOP TV News. Logos are trademarks of their owners.

Key takeaways

  • PAN 2, MBZUAI's 29B world model, now loads through ComfyUI's built-in UNETLoader and CLIPLoader after pull request #17755 merged into ComfyUI core on November 15, 2026.
  • The int8 checkpoint is 26.7 GB, down from 30.4 GB, and samples a 241-frame clip at 15.2 seconds a step on an RTX 5090 against 26.8 seconds a step for the dense build.
  • PAN 2 was trained on structured JSON captions, so a one-line prompt returns noise; the scene, event, subject, lighting, viewpoint and style fields have to be written before sampling.
  • There is no official workflow template yet, and PAN 2 support is on ComfyUI's master and nightly builds, not in any tagged release.

PAN 2 is MBZUAI's 29B world model, and this week it stopped being a custom node in ComfyUI. A pull request from the community developer Kijai merged into ComfyUI core on November 15, 2026, so PAN 2 now loads through the built-in UNETLoader and CLIPLoader, and image-to-video reuses the stock Wan 2.2 latent node. That matters if you have been holding off: the graph uses the same loaders as the rest of your library, with no separate pack to keep in sync with every ComfyUI release.

This guide covers what to download, how to wire the graph, the prompt structure PAN 2 expects, and the hardware it wants. The prompt step is the one people skip, and it produces noise if you do.

What PAN 2 is

PAN 2 is a general-purpose world model from the Institute of Foundation Models (IFM) at MBZUAI, released on November 10, 2026 under the Apache 2.0 license. Give it a starting scene, as text or an optional first frame, and an action described in words, and it simulates what happens next as a video. The model card states the output as 704x1248 at 24 fps, up to 20 seconds, with a default of 241 frames, about 10 seconds.

It couples two models. A language model, which IFM calls the conceptual reasoner, writes the next world state as a time-grounded description of events, actions bound to actors, and camera motion. A 29B MMDiT, the perceptual backbone, then predicts the video latents that fill in the detail the description leaves open, and a stock Wan 2.2 VAE decodes them. The text encoder is Qwen3.5-9B and it stays frozen, so what you tune is the prompt, not the model. For how PAN 2 sits among the other world models on the beat, our world models guide tracks the field.

What you actually need to download

Everything comes from the Comfy-Org/PAN2 repack on Hugging Face, which packages MBZUAI's original files as single safetensors for the standard ComfyUI model folders. You need one diffusion model, one text encoder and the VAE:

  • diffusion_models/pan2_int8_convrot.safetensors, 26.7 GB
  • diffusion_models/pan2_bf16.safetensors, 67.4 GB
  • text_encoders/qwen3.5_9b_int8_convrot.safetensors, 9.8 GB
  • text_encoders/qwen3.5_9b_bf16.safetensors, 19.3 GB
  • vae/wan2.2_vae.safetensors, 1.4 GB

The int8 pair is the practical choice for a single consumer card; the bf16 pair is the full-precision route for a machine with the memory for it. The VAE is the same Wan 2.2 file you may already have.

How to wire the graph

There is no official workflow template for PAN 2 yet, so the graph is built by hand. The chain is short:

UNETLoader → CLIPLoader (pan2) → CLIPTextEncode, plus Wan22ImageToVideoLatent for image-to-video, then KSampler → VAEDecode → CreateVideo.

The loader is where the native support shows. CLIPLoader gains a pan2 type, which runs stock Qwen3.5-9B, taps layer 30 of 32 without the final norm, and trims the caption span after the system turn. For image-to-video, the conditioning carries [latent * known, known] from latent_image and denoise_mask, which is what lets the existing Wan22ImageToVideoLatent node drive the first frame instead of a PAN 2-specific latent node. The native-ComfyUI report from ComfyUI Wiki lays out the same wiring.

The defaults match the authors' code: 50 steps, euler/simple, CFG 2.5, 24 fps and shift 9. One version note: the feature landed on ComfyUI's master branch, so PAN 2 support is in nightly builds only and not in any tagged release yet.

Why a one-line prompt returns noise

This is the step that trips people up. PAN 2 was trained on structured JSON captions, and a one-line prompt returns noise, including the one-liner in the model's own example. Write the scene, event, subject, lighting, viewpoint and style fields before you sample.

If you would rather not hand-write the JSON, the prompt rewriter's system prompt can run through TextGenerateV2 on the same text encoder file, which keeps the rewrite inside one graph. The model card says free-text prompts should be rewritten by a conceptual reasoner before generation, and the earlier ComfyUI Wiki launch report made the same point: a one-line prompt with an empty negative gives blown-out, mushy clips. If your first PAN 2 render looks like static, check the prompt format before you touch anything else.

What the int8 build buys you

Two engineering changes make the int8 checkpoint worth the download. The 44 per-block adaLN linears only ever read silu(temb(t)), so the checkpoint ships a 4097x192 curve table instead of the full time embedder; modulation error stays at 1.3e-4, and the int8 file drops from 30.4 GB to 26.7 GB. Separately, the video FFN now runs in token chunks with bit-identical output, which cuts the activation peak from 12.5 GB to 3.8 GB at 241 frames.

On an RTX 5090, a 241-frame clip samples at 15.2 seconds a step with int8 weights and int8 attention on the joint blocks, against 26.8 seconds a step for the dense build. The PR author checked same-seed clips visually and reports the velocity error matches int8 weights against bf16. BlockSparseAttention and EasyCache work on top of it unchanged.

The honest speed limit

15.2 seconds a step is not a small number. At the default 50 steps, that is about 760 seconds of sampling for one 241-frame clip, roughly 13 minutes before you account for loading, encoding and decoding. The sample attached to the PR is 2880x1172 at 24 fps, a large frame by any measure. The int8 route fits the model in 26.7 GB of weights plus a 3.8 GB activation peak, so it runs on one high-memory card; it does not turn a mid-range GPU into a world-model workstation.

The larger caveat is the model. MBZUAI's own model card says long plans fail often, with about two in three simulated multi-step plans containing at least one step the model does not carry out. Each clip is also simulated from at most one starting frame plus text, so appearance drifts across clips in long interactions. The clips are simulations, not records, and the card asks users to disclose that content is AI-generated where it could mislead.

What is still missing

Three things. No official workflow template, which is why the graph above is hand-built. No tagged release yet, so you need a nightly build off master. And the guardrail MBZUAI recommends, pan2-guardrail, ships separately from the weights, so the safety layer is an extra install rather than part of the download.

To start, pull the int8 pair and the Wan 2.2 VAE from the Comfy-Org/PAN2 repack, update ComfyUI to a nightly build off master, and build the graph by hand.

Sources

  1. comfyui-wiki.com
  2. github.com
  3. huggingface.co
  4. huggingface.co
  5. comfyui-wiki.com
  6. ifm.ai