I did not start with a beautiful graph. I started with a mess.
The first time I tried to get Wan2.2 running in ComfyUI, I loaded someone else’s workflow, watched half the nodes turn red, and spent the next two hours chasing missing custom nodes, mismatched model paths, and a VAE that refused to load without throwing a cryptic dtype error. By the time Nora was asleep and Biscuit had claimed the warm side of the desk, I had a working render and almost no idea which parts of the graph were actually required.
So I did the only thing that made sense. I deleted everything that was not strictly necessary and rebuilt from the smallest set of nodes that still produced a coherent video. That stripped-down graph became my personal baseline. This post is the walkthrough of that minimal workflow: what stayed, what got cut, why each remaining node exists, and the exact failure modes I hit while shrinking it.
If you can’t reproduce it, it’s not a workflow. Here is the smallest one I could make work on consumer hardware.
What “Minimal” Actually Means Here
Minimal does not mean “the fewest nodes possible in theory.” It means the fewest nodes that still:
Load the Wan2.2 model without silent fallbacks
Accept a text prompt and optional image input
Generate a short video clip with controllable frame count
Write a usable MP4
Run on a 24 GB RTX 3090 without requiring me to babysit offloading every step
I deliberately kept the graph readable. No nested subgraphs. No clever conditional routing. No extra upscalers, face restorers, or post-process nodes. Those can come later. First I needed a foundation that did not collapse when I changed one setting.
Hardware for all tests in this post:
GPU: used RTX 3090 (24 GB), secondhand card I repaired and dedicated to testing
System RAM: 64 GB
ComfyUI version: the one I had pinned at the time of these runs (I log the exact commit or release in the workflow notes)
Primary goal: get a stable 480p or 720p clip in the 16–24 frame range without the character wardrobe changing mid-shot
The Core Stages of the Minimal Graph
Every Wan2.2 video pipeline, no matter how fancy, still has to do the same basic jobs. I broke the graph into five stages and refused to add nodes that did not serve one of them.
1. Model Loading
This is where most of my early failures lived.
I ended up with a clean loading path that explicitly loads:
The Wan2.2 diffusion model
The text encoder(s)
The VAE
I stopped relying on “auto” loaders that sometimes grabbed the wrong precision or the wrong file from a crowded models folder. Explicit paths and explicit precision settings removed an entire class of “it worked yesterday” bugs.
One practical note: if you are on a 24 GB card, pay attention to whether the model is loading in full precision, fp16, or a quantized variant. The difference shows up immediately in peak VRAM and in whether the subsequent sampling stage has room to breathe.
2. Prompt Encoding
Text goes in. Conditioning comes out. That is the whole job of this stage.
I kept a single positive prompt path and a single negative prompt path. No dual CLIP setups, no style-specific weighting nodes, no automatic prompt expansion. Those are useful later. For the minimal graph they only added variables I did not need while I was still learning the model’s behavior.
I also made a habit of pasting the exact prompt text into the workflow notes so I could never lose the wording that produced a particular failure or success.
3. Sampling / Generation
This is the heart of the graph: the node (or small group of nodes) that actually runs the diffusion process for video.
Key controls I locked and documented every time:
Seed
Steps
Sampler name
Scheduler
CFG scale
Frame count
Resolution (width × height)
I treated frame count as a first-class variable. Changing it is not free. It changes memory behavior, temporal consistency, and total render time. The minimal workflow forces me to choose a frame count up front and live with the consequences instead of discovering them after a thirty-minute run.
4. VAE Decode
I learned the hard way that the VAE stage is not a passive afterthought.
In one early series of tests the diffusion stage looked fine in latent space, but the decoded frames introduced flicker and color shifts. Isolating the VAE—same latents, different decode settings or different VAE file—made the problem obvious. In the minimal graph the VAE decode is an explicit, visible step with its own notes. I do not bury it inside a mega-node that also does five other things.
5. Video Assembly and Save
The last stage turns the decoded frames into an MP4 (or image sequence if I need to inspect individual frames).
I kept this part deliberately boring: frame rate setting, output path, and a simple save node. No automatic ffmpeg filters, no watermarking, no social-media crop. Those belong in a later post-processing graph. The minimal workflow’s only job is to hand me a clean, reproducible clip I can watch and measure.
Nodes I Removed and Why
While shrinking the graph I cut several categories of nodes that felt useful but were not required for a baseline:
Extra detailers and face-fix nodes — they hide problems instead of showing them
Multiple parallel samplers — great for comparison later, confusing when you are still establishing the baseline
Automatic resolution or aspect-ratio calculators — I want to choose the resolution consciously
Complex prompt schedulers — one fixed prompt is enough while I learn temporal behavior
Any node whose only purpose was “it looked cool in someone else’s screenshot”
Every time I removed a node I re-ran the same seed and prompt. If the output stayed within the same failure modes I already understood, the node was optional. If the output changed in a way I could not explain, I put the node back and investigated.
The First Stable Run I Trusted
After several nights of pruning, I had a graph that could:
Load without errors on a cold start
Accept a simple text prompt
Produce a 16-frame 480p clip
Stay under the 24 GB ceiling without aggressive offloading
Repeat the same seed with only minor, expected variation
It was not pretty. The motion was stiff. The lighting was flat. The character’s jacket still tried to change color on longer runs. But the failures were consistent. That consistency is what made the graph worth keeping.
I saved the workflow JSON, the exact prompt, the seed, the model filenames, and a short note about peak VRAM. That package—not the pretty final clip—became the real deliverable.
Practical Advice If You Want to Build Your Own Minimal Graph
Start by loading a working workflow from someone else, then delete nodes one at a time while keeping the seed fixed.
After every deletion, run the same prompt and compare the output to the previous version. If you cannot explain the difference, put the node back.
Write the full settings into a text node or a sidecar note inside the workflow itself. Future you will not remember the CFG value you used at 11:40 p.m.
Treat the VAE as a separate variable. Swap it deliberately instead of assuming the one that loaded automatically is optimal.
Measure peak VRAM on the first clean run. If you are already near the limit on a short clip, longer frame counts will hurt.
What This Minimal Workflow Is Not
It is not the highest-quality setup I have.
It is not the fastest.
It is not the one I would hand to a client for final delivery.
It is the smallest graph I trust enough to use as a measuring stick. Every later experiment—higher resolution, more frames, offloading versus quantization, different samplers—starts from this baseline so I know what changed and why.
Closing
Building the smallest working Wan2.2 workflow forced me to stop treating ComfyUI graphs as magic spellbooks and start treating them as engineering diagrams. Every node has a cost. Every missing note has a future cost.
The settings are part of the result.
I will publish the actual minimal workflow JSON and the accompanying notes in a follow-up once I have cleaned the file paths and verified it loads on a fresh ComfyUI install. Until then, the principle stands:
Run the test. Save the settings. Show the failure.
If you can’t reproduce it, it’s not a workflow.
