python - <<'PY'
import json, urllib.request
base='http://100.101.173.25:8188'
workflow=json.load(open('data/comfyui_scene01_gpu_preview_workflow.json'))
payload=json.dumps({'prompt': workflow, 'client_id': 'hermes-autoshorts-scene01-gpu-preview'}).encode()
req=urllib.request.Request(base+'/prompt', data=payload, headers={'Content-Type':'application/json'})
try:
    print(urllib.request.urlopen(req, timeout=30).read().decode())
except Exception as e:
    print('ERROR', type(e).__name__, e)
    if hasattr(e, 'read'):
        print(e.read().decode())
PY


terminal

Output: {"prompt_id": "8d6126de-549e-411f-b61d-fe11b4f42935", "number": 0, "node_errors": {}}


Now monitor maybe nvidia stats via system_stats includes vram. Need poll.

python - <<'PY'
import json, time, urllib.request, urllib.error
base='http://100.101.173.25:8188'
pid='8d6126de-549e-411f-b61d-fe11b4f42935'
for i in range(100):
    try:
        q=json.load(urllib.request.urlopen(base+'/queue', timeout=10))
        s=json.load(urllib.request.urlopen(base+'/system_stats', timeout=10))
        running=len(q.get('queue_running', [])); pending=len(q.get('queue_pending', []))
        d=s['devices'][0]
        vused=(d['vram_total']-d['vram_free'])/1024**3
        print(f'poll {i:02d}: running={running} pending={pending} vram_used_gb={vused:.2f} ram_free_gb={s["system"]["ram_free"]/1024**3:.2f}')
        if not running and not pending:
            break
    except Exception as e:
        print('POLL_ERROR', type(e).__name__, e)
        raise
    time.sleep(5)
h=json.load(urllib.request.urlopen(base+'/history/'+pid, timeout=20))
print('STATUS')
print(json.dumps(h.get(pid, {}).get('status',{}), indent=2))
print('OUTPUTS')
print(json.dumps(h.get(pid, {}).get('outputs',{}), indent=2))
PY


Output:
poll 00: running=1 pending=0 vram_used_gb=8.11 ram_free_gb=16.66
poll 01: running=1 pending=0 vram_used_gb=8.11 ram_free_gb=16.68
poll 02: running=1 pending=0 vram_used_gb=10.48 ram_free_gb=16.14
poll 03: running=0 pending=0 vram_used_gb=7.97 ram_free_gb=15.99
STATUS
{
  "status_str": "success",
  "completed": true,
  "messages": [
    [
      "execution_start",
      {
        "prompt_id": "8d6126de-549e-411f-b61d-fe11b4f42935",
        "timestamp": 1779552918455
      }
    ],
    [
      "execution_cached",
      {
        "nodes": [],
        "prompt_id": "8d6126de-549e-411f-b61d-fe11b4f42935",
        "timestamp": 1779552918457
      }
    ],
    [
      "execution_success",
      {
        "prompt_id": "8d6126de-549e-411f-b61d-fe11b4f42935",
        "timestamp": 1779552965577
      }
    ]
  ]
}
OUTPUTS
{
  "9": {
    "images": [
      {
        "filename": "autoshorts_scene01_gpu_preview_00001_.mp4",
        "subfolder": "",
        "type": "output"
      }
    ],
    "animated": [
      true
    ]
  }
}


python - <<'PY'
import urllib.parse, urllib.request, pathlib
base='http://100.101.173.25:8188'
fn='autoshorts_scene01_gpu_preview_00001_.mp4'
params=urllib.parse.urlencode({'filename':fn,'subfolder':'','type':'output'})
out=pathlib.Path('/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/'+fn)
out.parent.mkdir(parents=True, exist_ok=True)
out.write_bytes(urllib.request.urlopen(base+'/view?'+params, timeout=90).read())
print(out, out.stat().st_size)
PY
ffprobe -v error -select_streams v:0 -show_entries stream=width,height,avg_frame_rate,duration -of default=nw=1:nk=1 data/comfyui_outputs/autoshorts_scene01_gpu_preview_00001_.mp4
mkdir -p /tmp/autoshorts_comfy_check && ffmpeg -y -i data/comfyui_outputs/autoshorts_scene01_gpu_preview_00001_.mp4 -vf "select=eq(n\,12)" -frames:v 1 /tmp/autoshorts_comfy_check/scene01_gpu_preview_mid.jpg >/dev/null 2>&1 && ls -lh /tmp/autoshorts_comfy_check/scene01_gpu_preview_mid.jpg


Output:
/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/autoshorts_scene01_gpu_preview_00001_.mp4 28831
416
736
12/1
2.083333
-rw-rw-r-- 1 agent agent 7,5K Mai 23 18:16 /tmp/autoshorts_comfy_check/scene01_gpu_preview_mid.jpg


Question: Bitte beurteile den Frame knapp: Ist ein Auto/Garagenmotiv erkennbar oder weiterhin nur abstrakte Farben/Artefakte? Eignet sich der Clip als brauchbare B-Roll?


Image loaded into your context — you can see it natively now. Use your built-in vision to answer the user.

Question: Bitte beurteile den Frame knapp: Ist ein Auto/Garagenmotiv erkennbar oder weiterhin nur abstrakte Farben/Artefakte? Eignet sich der Clip als brauchbare B-Roll?


Explanation:
**Considering output setup**

I’m thinking about running the next output with a resolution of 480x832, 33 frames, and 10 steps since it worked quickly before. The user might've asked for a new start command, but we’ve already run it. I could aim for higher quality or test the same settings again, but manage the possibility of running out of memory. I should also verify that it remains recognizable, so I’ll proceed with caution. Let's go ahead and run it.

Vertical realistic cinematic documentary video. A cheap used red compact car partially enters a dim independent garage at night. Camera slowly pushes in from the front corner of the car, subtle red warning reflection, realistic car paint, dramatic shadows, shallow depth of field, clean dark background, high contrast, no readable text, no subtitles, no logo, no watermark, negative space for captions.

readable text, subtitles, logos, watermark, fake UI, distorted car, deformed vehicle, extra wheels, cartoon, anime, static image, abstract colors, flickering lights only, blurry, low detail


python - <<'PY'
import json, urllib.request
base='http://100.101.173.25:8188'
workflow=json.load(open('data/comfyui_scene01_gpu_480x832_workflow.json'))
payload=json.dumps({'prompt': workflow, 'client_id': 'hermes-autoshorts-scene01-gpu-480x832'}).encode()
req=urllib.request.Request(base+'/prompt', data=payload, headers={'Content-Type':'application/json'})
print(urllib.request.urlopen(req, timeout=30).read().decode())
PY


Output: {"prompt_id": "283de2c2-e617-4bbd-b9bb-1b3a4f5c73f2", "number": 1, "node_errors": {}}


python - <<'PY'
import json, time, urllib.request
base='http://100.101.173.25:8188'
pid='283de2c2-e617-4bbd-b9bb-1b3a4f5c73f2'
for i in range(120):
    q=json.load(urllib.request.urlopen(base+'/queue', timeout=10))
    s=json.load(urllib.request.urlopen(base+'/system_stats', timeout=10))
    running=len(q.get('queue_running', [])); pending=len(q.get('queue_pending', []))
    d=s['devices'][0]
    vused=(d['vram_total']-d['vram_free'])/1024**3
    print(f'poll {i:02d}: running={running} pending={pending} vram_used_gb={vused:.2f} ram_free_gb={s["system"]["ram_free"]/1024**3:.2f}')
    if not running and not pending:
        break
    time.sleep(5)
h=json.load(urllib.request.urlopen(base+'/history/'+pid, timeout=20))
print('STATUS')
print(json.dumps(h.get(pid, {}).get('status',{}), indent=2))
print('OUTPUTS')
print(json.dumps(h.get(pid, {}).get('outputs',{}), indent=2))
PY


Output:
poll 00: running=1 pending=0 vram_used_gb=8.19 ram_free_gb=14.84
poll 01: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.79
poll 02: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.88
poll 03: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.90
poll 04: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.86
poll 05: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.90
poll 06: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.84
poll 07: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.91
poll 08: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.89
poll 09: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.92
poll 10: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.90
poll 11: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.89
poll 12: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.91
poll 13: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.94
poll 14: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.98
poll 15: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.66
poll 16: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.47
poll 17: running=1 pending=0 vram_used_gb=8.00 ram_free_gb=14.41
poll 18: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.82
poll 19: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.74
poll 20: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.56
poll 21: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.44
poll 22: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.55
poll 23: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.51
poll 24: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.54
poll 25: running=1 pending=0 vram_used_gb=8.20 ram_free_gb=14.53
poll 26: running=1 pending=0 vram_used_gb=10.18 ram_free_gb=14.52
poll 27: running=1 pending=0 vram_used_gb=10.26 ram_free_gb=14.49
poll 28: running=1 pending=0 vram_used_gb=10.07 ram_free_gb=14.54
poll 29: running=1 pending=0 vram_used_gb=8.28 ram_free_gb=14.56
poll 30: running=1 pending=0 vram_used_gb=8.28 ram_free_gb=14.52
poll 31: running=0 pending=0 vram_used_gb=7.97 ram_free_gb=14.39
STATUS
{
  "status_str": "success",
  "completed": true,
  "messages": [
    [
      "execution_start",
      {
        "prompt_id": "283de2c2-e617-4bbd-b9bb-1b3a4f5c73f2",
        "timestamp": 1779553026420
      }
    ],
    [
      "execution_cached",
      {
        "nodes": [
          "1",
          "2",
          "6"
        ],
        "prompt_id": "283de2c2-e617-4bbd-b9bb-1b3a4f5c73f2",
        "timestamp": 1779553026423
      }
    ],
    [
      "execution_success",
      {
        "prompt_id": "283de2c2-e617-4bbd-b9bb-1b3a4f5c73f2",
        "timestamp": 1779553186754
      }
    ]
  ]
}
OUTPUTS
{
  "9": {
    "images": [
      {
        "filename": "autoshorts_scene01_gpu_480x832_00001_.mp4",
        "subfolder": "",
        "type": "output"
      }
    ],
    "animated": [
      true
    ]
  }
}


Download.

Download.

python - <<'PY'
import urllib.parse, urllib.request, pathlib
base='http://100.101.173.25:8188'
fn='autoshorts_scene01_gpu_480x832_00001_.mp4'
params=urllib.parse.urlencode({'filename':fn,'subfolder':'','type':'output'})
out=pathlib.Path('/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/'+fn)
out.parent.mkdir(parents=True, exist_ok=True)
out.write_bytes(urllib.request.urlopen(base+'/view?'+params, timeout=120).read())
print(out, out.stat().st_size)
PY
ffprobe -v error -select_streams v:0 -show_entries stream=width,height,avg_frame_rate,duration -of default=nw=1:nk=1 data/comfyui_outputs/autoshorts_scene01_gpu_480x832_00001_.mp4
ffmpeg -y -i data/comfyui_outputs/autoshorts_scene01_gpu_480x832_00001_.mp4 -vf "select=eq(n\,16)" -frames:v 1 /tmp/autoshorts_comfy_check/scene01_gpu_480_mid.jpg >/dev/null 2>&1 && ls -lh /tmp/autoshorts_comfy_check/scene01_gpu_480_mid.jpg


Output:
/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/autoshorts_scene01_gpu_480x832_00001_.mp4 58575
480
832
12/1
2.750000
-rw-rw-r-- 1 agent agent 16K Mai 23 18:19 /tmp/autoshorts_comfy_check/scene01_gpu_480_mid.jpg


Question: Beurteile knapp den Frame: Ist ein Auto/Garagenmotiv klar erkennbar? Ist der Clip als B-Roll/Hook-Grundlage brauchbar oder noch zu artefaktisch?


Image loaded into your context — you can see it natively now. Use your built-in vision to answer the user.

Question: Beurteile knapp den Frame: Ist ein Auto/Garagenmotiv klar erkennbar? Ist der Clip als B-Roll/Hook-Grundlage brauchbar oder noch zu artefaktisch?


Perfekt, Sir. Ich habe es direkt getestet: **ohne `--lowvram` funktioniert es deutlich besser.**

## Ergebnis

ComfyUI läuft jetzt korrekt mit:

```text
main.py --listen 100.101.173.25 --port 8188 --reserve-vram 1.0
```

Ich habe von hier aus zwei neue GPU-Workflows gestartet.

---

## Test 1 — 416×736, 25 Frames, 8 Steps

Settings:

```text
416x736
25 Frames
12 fps
8 Steps
T5/Textencoder: GPU
Wan model: main_device
VAE tiling: off
```

Laufzeit:

```text
ca. 47 Sekunden
```

GPU-Auslastung laut ComfyUI-Systemstats:

```text
VRAM used: ca. 8–10.5 GB
```

Output:

```text
data/comfyui_outputs/autoshorts_scene01_gpu_preview_00001_.mp4
```

Video:

MEDIA:/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/autoshorts_scene01_gpu_preview_00001_.mp4

Visuell: **endlich erkennbar** — rotes Auto in dunkler Garage. Noch nicht final, aber kein blinkender Pixelbrei mehr.

---

## Test 2 — 480×832, 33 Frames, 10 Steps

Settings:

```text
480x832
33 Frames
12 fps
10 Steps
Dauer: 2.75 Sekunden
T5/Textencoder: GPU
Wan model: main_device
VAE tiling: off
```

Laufzeit:

```text
ca. 160 Sekunden
```

GPU-Auslastung:

```text
VRAM used: ca. 8.2–10.3 GB
```

Output:

```text
data/comfyui_outputs/autoshorts_scene01_gpu_480x832_00001_.mp4
```

Video:

MEDIA:/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/autoshorts_scene01_gpu_480x832_00001_.mp4

Visuelle Diagnose:
**Auto/Garage ist klar erkennbar.** Dunkel, filmisch, rotes Auto, Close-up. Als Hook-B-Roll-Grundlage brauchbar. Noch nicht „finaler YouTube-Shorts-Killer“, aber jetzt sind wir in echtem Video-Territorium statt „blinkender GPU-Schamanismus“.

---

# Neuer Standard-Startbefehl

Bitte ab jetzt für lokale Video-Generierung:

```bash
cd ~/ai/ComfyUI
source .venv/bin/activate

TS_IP="$(tailscale ip -4 2>/dev/null | head -n1 || true)"
[ -z "$TS_IP" ] && TS_IP="127.0.0.1"

python main.py \
  --listen "$TS_IP" \
  --port 8188 \
  --reserve-vram 1.0
```

## Nicht mehr standardmäßig verwenden

```bash
--lowvram
```

`--lowvram` nur noch bei Crash/OOM.

---

# Wenn du noch mehr Speed bei wiederholten Runs willst

Später testen wir:

```bash
cd ~/ai/ComfyUI
source .venv/bin/activate

TS_IP="$(tailscale ip -4 2>/dev/null | head -n1 || true)"
[ -z "$TS_IP" ] && TS_IP="127.0.0.1"

python main.py \
  --listen "$TS_IP" \
  --port 8188 \
  --highvram \
  --reserve-vram 1.0
```

Aber erst später. Aktuell ist der normale Modus stabil und nutzt die GPU.

---

# Workflow-Anpassungen, die jetzt gelten

## 1. Textencoder auf GPU

Neu:

```text
WanVideoTextEncode device = gpu
LoadWanVideoT5TextEncoder load_device = main_device
```

Nicht mehr:

```text
device = cpu
load_device = offload_device
```

Das war der Grund, warum T5 ewig dauerte.

---

## 2. Wan Model auf GPU/main_device

Neu:

```text
WanVideoModelLoader load_device = main_device
```

Nicht mehr:

```text
offload_device
```

Für `Wan2.1 T2V 1.3B FP8` passt das auf deiner A5000.

---

## 3. VAE Tiling aus

Neu:

```text
enable_vae_tiling = false
```

Nur bei OOM:

```text
enable_vae_tiling = true
tile_x = 256
tile_y = 256
tile_stride_x = 128
tile_stride_y = 128
```

---

# Empfohlene Produktionsprofile

## Fast Preview / Prompt-Iteration

Das ist aktuell der Sweet Spot:

```text
416x736
25 Frames
12 fps
8 Steps
```

Dauer:

```text
~45–60 Sekunden
```

Nutzen:

```text
schnell genug für Varianten
gut genug, um Motiv/Komposition zu beurteilen
```

## Better Preview / Kandidat

```text
480x832
33 Frames
12 fps
10 Steps
```

Dauer:

```text
~2.5–3 Minuten
```

Nutzen:

```text
brauchbare B-Roll-Basis
besserer Bildaufbau
mehr Bewegung
```

## Noch nicht sofort

```text
720x1280
49–81 Frames
20+ Steps
14B Modell
```

Das wäre jetzt unnötig schwer. Erst Prompt-/Shot-Struktur sauber bekommen.

---

# Warum `nvidia-smi` vorher nur ~1 GB zeigte

Weil wir im Notfallmodus waren:

```text
--lowvram
Textencoder auf CPU
Model offload_device
winzige Auflösung
2–4 Steps
```

Jetzt sah ich während der Jobs:

```text
8–10.5 GB VRAM used
```

Also: GPU wird jetzt genutzt.

---

# Nächster Schritt

Ich würde jetzt im Repo den **ComfyUI Wan Client** als feste Pipeline-Komponente bauen:

```text
Scene Spec
→ Workflow JSON
→ ComfyUI /prompt
→ Poll /queue + /history
→ Download /view
→ speichern als:
data/imported_ai_clips/.../scene_01.mp4
```

Dann können wir automatisiert Varianten erzeugen:

```text
scene_01_seed_1.mp4
scene_01_seed_2.mp4
scene_01_seed_3.mp4
```

und die beste Variante in den Hybrid-Renderer ziehen.

Kurz: **Startbefehl ist jetzt `--reserve-vram 1.0`, nicht `--lowvram`. GPU-Pipeline funktioniert. Erste brauchbare Auto-B-Roll ist erzeugt.**


[M G] sollen wir Wan 2.2 TI2V 5B testen für bessere qualität? Wan 2.2 wurde mit deutlich mehr Daten trainiert: laut Modellkarte mit +65.6 % mehr Bildern und +83.2 % mehr Videos gegenüber Wan 2.1. Das soll besonders Bewegung, Semantik und Ästhetik verbessern. Ausserdem unterstützt das Wan2.2-TI2V-5B Text-to-Video und Image-to-Video in einem Modell und ist für 720p bei 24 FPS ausgelegt.


python - <<'PY'
import json, urllib.request
repos=['Kijai/WanVideo_comfy','Kijai/WanVideo_comfy_fp8_scaled','Comfy-Org/Wan_2.2_ComfyUI_Repackaged']
for repo in repos:
 print('\n##',repo)
 try:
  data=json.load(urllib.request.urlopen(f'https://huggingface.co/api/models/{repo}/tree/main?recursive=1',timeout=30))
  for x in data:
   p=x.get('path','')
   if any(s in p.lower() for s in ['2_2','2.2','ti2v','5b','umt5','vae']):
    print(p, round((x.get('size') or 0)/1024**3,2),'GB')
 except Exception as e: print('ERR',type(e).__name__,e)
PY


Output:
## Kijai/WanVideo_comfy
FastWan/Wan2_2-TI2V-5B-FastWanFullAttn_bf16.safetensors 9.31 GB
FastWan/Wan2_2_5B_FastWanFullAttn_lora_rank_128_bf16.safetensors 0.62 GB
FlowRVS/wan21_flow_rvs_mask_vae_bf16.safetensors 0.24 GB
Fun/VACE/Wan2_2_Fun_VACE_module_A14B_HIGH_bf16.safetensors 5.68 GB
Fun/VACE/Wan2_2_Fun_VACE_module_A14B_LOW_bf16.safetensors 5.68 GB
LoRAs/AniSora/Wan2_2_I2V_AniSora_3_2_HIGH_rank_64_fp16.safetensors 0.59 GB
LoRAs/Stable-Video-Infinity/v2.0/SVI_Wan2.2-I2V-A14B_lora_HIGH_v2.0_rank_128_fp16.safetensors 1.14 GB
LoRAs/Stable-Video-Infinity/v2.0/SVI_Wan2.2-I2V-A14B_lora_LOW_v2.0_rank_128_fp16.safetensors 1.14 GB
LoRAs/Stable-Video-Infinity/v2.0/SVI_v2_PRO_Wan2.2-I2V-A14B_HIGH_lora_rank_128_fp16.safetensors 1.14 GB
LoRAs/Stable-Video-Infinity/v2.0/SVI_v2_PRO_Wan2.2-I2V-A14B_LOW_lora_rank_128_fp16.safetensors 1.14 GB
LoRAs/Stand-In/Stand-In_wan2.2_T2V_A14B_HIGH_fp16.safetensors 0.29 GB
LoRAs/Stand-In/Stand-In_wan2.2_T2V_A14B_LOW_fp16.safetensors 0.29 GB
LoRAs/Wan22-Lightning/old/Wan2.2-Lightning_I2V-A14B-4steps-lora_HIGH_fp16.safetensors 0.57 GB
LoRAs/Wan22-Lightning/old/Wan2.2-Lightning_I2V-A14B-4steps-lora_LOW_fp16.safetensors 0.57 GB
LoRAs/Wan22-Lightning/old/Wan2.2-Lightning_T2V-A14B-4steps-lora_HIGH_fp16.safetensors 0.57 GB
LoRAs/Wan22-Lightning/old/Wan2.2-Lightning_T2V-A14B-4steps-lora_LOW_fp16.safetensors 0.57 GB
LoRAs/Wan22-Lightning/old/Wan2.2-Lightning_T2V-v1.1-A14B-4steps-lora_HIGH_fp16.safetensors 0.57 GB
LoRAs/Wan22-Lightning/old/Wan2.2-Lightning_T2V-v1.1-A14B-4steps-lora_LOW_fp16.safetensors 0.57 GB
LoRAs/Wan22-Turbo/Wan22_TI2V_5B_Turbo_lora_rank_64_fp16.safetensors 0.31 GB
LoRAs/Wan22-Turbo/Wan22_TI2V_5B_Turbo_lora_rank_adaptive_quantile_0.15_fp16.safetensors 0.18 GB
LoRAs/Wan22_FunReward/Wan2.2-Fun-A14B-InP-HIGH-HPS2.1_resized_dynamic_avg_rank_14_bf16.safetensors 0.09 GB
LoRAs/Wan22_FunReward/Wan2.2-Fun-A14B-InP-HIGH-MPS_resized_dynamic_avg_rank_21_bf16.safetensors 0.13 GB
LoRAs/Wan22_FunReward/Wan2.2-Fun-A14B-InP-LOW-HPS2.1_resized_dynamic_avg_rank_15_bf16.safetensors 0.09 GB
LoRAs/Wan22_FunReward/Wan2.2-Fun-A14B-InP-LOW-MPS_resized_dynamic_avg_rank_22_bf16.safetensors 0.14 GB
LoRAs/Wan22_Lightx2v/Wan_2_2_I2V_A14B_HIGH_lightx2v_4step_lora_260412_rank_256_fp16.safetensors 2.33 GB
LoRAs/Wan22_Lightx2v/Wan_2_2_I2V_A14B_HIGH_lightx2v_4step_lora_260412_rank_64_fp16.safetensors 0.59 GB
LoRAs/Wan22_Lightx2v/Wan_2_2_I2V_A14B_HIGH_lightx2v_4step_lora_v1030_rank_64_bf16.safetensors 0.59 GB
LoRAs/Wan22_Lightx2v/Wan_2_2_I2V_A14B_HIGH_lightx2v_MoE_distill_lora_rank_64_bf16.safetensors 0.59 GB
LoRAs/Wan22_Lightx2v/Wan_2_2_I2V_A14B_LOW_lightx2v_4step_lora_260412_rank_256_fp16.safetensors 2.33 GB
LoRAs/Wan22_Lightx2v/Wan_2_2_I2V_A14B_LOW_lightx2v_4step_lora_260412_rank_64_fp16.safetensors 0.59 GB
MTVCrafter/WanVideo_MTV_Crafter_4DMoT_VQVAE_fp32.safetensors 0.27 GB
Ovi/Wan_2_2_Ovi_audio_model_bf16.safetensors 11.35 GB
Ovi/Wan_2_2_Ovi_video_model_bf16.safetensors 10.37 GB
Ovi/mmaudio_vae_16k_bf16.safetensors 0.32 GB
Ovi/mmaudio_vae_16k_fp32.safetensors 0.64 GB
Wan22-Turbo/Wan2_2-TI2V-5B-Turbo_fp16.safetensors 9.49 GB
Wan2_1_VAE_bf16.safetensors 0.24 GB
Wan2_1_VAE_fp32.safetensors 0.47 GB
Wan2_2-I2V-A14B-HIGH_bf16.safetensors 26.62 GB
Wan2_2-I2V-A14B-LOW_bf16.safetensors 26.62 GB
Wan2_2_VAE_bf16.safetensors 1.31 GB
taew2_2.safetensors 0.02 GB
umt5-xxl-enc-bf16.safetensors 10.58 GB
umt5-xxl-enc-fp8_e4m3fn.safetensors 6.27 GB

## Kijai/WanVideo_comfy_fp8_scaled
TI2V 0.0 GB
TI2V/Ovi 0.0 GB
Fun/Wan2_2-Fun-Control-A14B-HIGH_fp8_e4m3fn_scaled_KJ_fixed.safetensors 13.53 GB
Fun/Wan2_2-Fun-Control-A14B-HIGH_fp8_e5m2_scaled_KJ_fixed.safetensors 13.53 GB
Fun/Wan2_2-Fun-Control-A14B-LOW_fp8_e4m3fn_scaled_KJ_fixed.safetensors 13.53 GB
Fun/Wan2_2-Fun-Control-A14B-LOW_fp8_e5m2_scaled_KJ_fixed.safetensors 13.53 GB
Fun/Wan2_2-Fun-Control-Camera-A14B-HIGH_fp8_e4m3fn_scaled_KJ.safetensors 14.47 GB
Fun/Wan2_2-Fun-Control-Camera-A14B-LOW_fp8_e4m3fn_scaled_KJ.safetensors 14.47 GB
Fun/Wan2_2-Fun-InP-A14B-HIGH_fp8_e4m3fn_scaled_KJ.safetensors 13.53 GB
Fun/Wan2_2-Fun-InP-A14B-LOW_fp8_e4m3fn_scaled_KJ.safetensors 13.53 GB
I2V/AniSora/Wan2_2-I2V_AniSoraV3_2_HIGH_14B_fp8_e4m3fn_scaled_KJ.safetensors 13.97 GB
I2V/AniSora/Wan2_2-I2V_AniSoraV3_2_LOW_14B_fp8_e4m3fn_scaled_KJ.safetensors 13.97 GB
I2V/Wan2_2-I2V-A14B-HIGH_fp8_e4m3fn_scaled_KJ.safetensors 13.97 GB
I2V/Wan2_2-I2V-A14B-HIGH_fp8_e5m2_scaled_KJ.safetensors 13.97 GB
I2V/Wan2_2-I2V-A14B-LOW_fp8_e4m3fn_scaled_KJ.safetensors 13.97 GB
I2V/Wan2_2-I2V-A14B-LOW_fp8_e5m2_scaled_KJ.safetensors 13.97 GB
S2V/Wan2_2-S2V-14B_fp8_e4m3fn_scaled_KJ.safetensors 15.51 GB
T2V/HoloCine/Wan2_2-T2V-A14B-HIGH-HoloCine-full_fp8_e4m3fn_scaled_KJ.safetensors 13.97 GB
T2V/HoloCine/Wan2_2-T2V-A14B-LOW-HoloCine-full_fp8_e4m3fn_scaled_KJ.safetensors 13.97 GB
T2V/Wan2_2-T2V-A14B-HIGH_4_steps-250928-dyno-lightx2v_fp8_e4m3fn_scaled_KJ.safetensors 13.53 GB
T2V/Wan2_2-T2V-A14B-HIGH_fp8_e5m2_scaled_KJ.safetensors 13.97 GB
T2V/Wan2_2-T2V-A14B-LOW_fp8_e4m3fn_scaled_KJ.safetensors 13.97 GB
T2V/Wan2_2-T2V-A14B-LOW_fp8_e5m2_scaled_KJ.safetensors 13.97 GB
T2V/Wan2_2-T2V-A14B_HIGH_fp8_e4m3fn_scaled_KJ.safetensors 13.97 GB
TI2V/Ovi/README.md 0.0 GB
TI2V/Ovi/Wan2_2-5B-Ovi_960x960_10s_fp8_e4m3fn_scaled_KJ.safetensors 11.52 GB
TI2V/Ovi/Wan2_2-5B-Ovi_960x960_fp8_e4m3fn_scaled_KJ.safetensors 11.52 GB
TI2V/Ovi/Wan2_2_Ovi_Audio_fp8_e4m3fn_scaled_KJ.safetensors 6.25 GB
TI2V/Ovi/Wan2_2_Ovi_Video_fp8_e4m3fn_scaled_KJ.safetensors 5.27 GB
TI2V/Wan2_2-TI2V-5B_fp8_e4m3fn_scaled_KJ.safetensors 4.91 GB
TI2V/Wan2_2-TI2V-5B_fp8_e5m2_scaled_KJ.safetensors 4.91 GB
VACE/Wan2_2_Fun_VACE_module_A14B_HIGH_fp8_e4m3fn_scaled_KJ.safetensors 2.84 GB
VACE/Wan2_2_Fun_VACE_module_A14B_HIGH_fp8_e5m2_scaled_KJ.safetensors 2.84 GB
VACE/Wan2_2_Fun_VACE_module_A14B_LOW_fp8_e4m3fn_scaled_KJ.safetensors 2.84 GB
VACE/Wan2_2_Fun_VACE_module_A14B_LOW_fp8_e5m2_scaled_KJ.safetensors 2.84 GB
Wan22Animate/Wan2_2-Animate-14B_fp8_e4m3fn_scaled_KJ.safetensors 17.14 GB
Wan22Animate/Wan2_2-Animate-14B_fp8_e5m2_scaled_KJ.safetensors 17.14 GB
Wan22Animate/Wan2_2-Animate-14B_fp8_scaled_e4m3fn_KJ_v2.safetensors 16.13 GB
Wan22Animate/Wan2_2-Animate-14B_fp8_scaled_e5m2_KJ_v2.safetensors 16.13 GB

## Comfy-Org/Wan_2.2_ComfyUI_Repackaged
split_files/vae 0.0 GB
split_files/diffusion_models/wan2.2_animate_14B_bf16.safetensors 32.18 GB
split_files/diffusion_models/wan2.2_fun_camera_high_noise_14B_bf16.safetensors 27.55 GB
split_files/diffusion_models/wan2.2_fun_camera_high_noise_14B_fp8_scaled.safetensors 14.25 GB
split_files/diffusion_models/wan2.2_fun_camera_low_noise_14B_bf16.safetensors 27.55 GB
split_files/diffusion_models/wan2.2_fun_camera_low_noise_14B_fp8_scaled.safetensors 14.25 GB
split_files/diffusion_models/wan2.2_fun_control_5B_bf16.safetensors 9.32 GB
split_files/diffusion_models/wan2.2_fun_control_high_noise_14B_bf16.safetensors 26.62 GB
split_files/diffusion_models/wan2.2_fun_control_high_noise_14B_fp8_scaled.safetensors 13.31 GB
split_files/diffusion_models/wan2.2_fun_control_low_noise_14B_bf16.safetensors 26.62 GB
split_files/diffusion_models/wan2.2_fun_control_low_noise_14B_fp8_scaled.safetensors 13.31 GB
split_files/diffusion_models/wan2.2_fun_inpaint_5B_bf16.safetensors 9.31 GB
split_files/diffusion_models/wan2.2_fun_inpaint_high_noise_14B_bf16.safetensors 26.62 GB
split_files/diffusion_models/wan2.2_fun_inpaint_high_noise_14B_fp8_scaled.safetensors 13.31 GB
split_files/diffusion_models/wan2.2_fun_inpaint_low_noise_14B_bf16.safetensors 26.62 GB
split_files/diffusion_models/wan2.2_fun_inpaint_low_noise_14B_fp8_scaled.safetensors 13.31 GB
split_files/diffusion_models/wan2.2_fun_vace_high_noise_14B_bf16.safetensors 32.29 GB
split_files/diffusion_models/wan2.2_fun_vace_high_noise_14B_fp8_scaled.safetensors 16.15 GB
split_files/diffusion_models/wan2.2_fun_vace_low_noise_14B_bf16.safetensors 32.29 GB
split_files/diffusion_models/wan2.2_fun_vace_low_noise_14B_fp8_scaled.safetensors 16.15 GB
split_files/diffusion_models/wan2.2_i2v_high_noise_14B_fp16.safetensors 26.62 GB
split_files/diffusion_models/wan2.2_i2v_high_noise_14B_fp8_scaled.safetensors 13.31 GB
split_files/diffusion_models/wan2.2_i2v_low_noise_14B_fp16.safetensors 26.62 GB
split_files/diffusion_models/wan2.2_i2v_low_noise_14B_fp8_scaled.safetensors 13.31 GB
split_files/diffusion_models/wan2.2_s2v_14B_bf16.safetensors 30.35 GB
split_files/diffusion_models/wan2.2_s2v_14B_fp8_scaled.safetensors 15.27 GB
split_files/diffusion_models/wan2.2_t2v_high_noise_14B_fp16.safetensors 26.61 GB
split_files/diffusion_models/wan2.2_t2v_high_noise_14B_fp8_scaled.safetensors 13.31 GB
split_files/diffusion_models/wan2.2_t2v_low_noise_14B_fp16.safetensors 26.61 GB
split_files/diffusion_models/wan2.2_t2v_low_noise_14B_fp8_scaled.safetensors 13.31 GB
split_files/diffusion_models/wan2.2_ti2v_5B_fp16.safetensors 9.31 GB
split_files/loras/wan2.2_animate_14B_relight_lora_bf16.safetensors 1.34 GB
split_files/loras/wan2.2_i2v_lightx2v_4steps_lora_v1_high_noise.safetensors 1.14 GB
split_files/loras/wan2.2_i2v_lightx2v_4steps_lora_v1_low_noise.safetensors 1.14 GB
split_files/loras/wan2.2_t2v_lightx2v_4steps_lora_v1.1_high_noise.safetensors 1.14 GB
split_files/loras/wan2.2_t2v_lightx2v_4steps_lora_v1.1_low_noise.safetensors 1.14 GB
split_files/text_encoders/umt5_xxl_fp16.safetensors 10.59 GB
split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors 6.27 GB
split_files/vae/wan2.2_vae.safetensors 1.31 GB
split_files/vae/wan_2.1_vae.safetensors 0.24 GB


Ja, Sir — **Wan 2.2 TI2V 5B sollten wir testen.**
Aber bitte **nicht blind als “720p 24 FPS final”**, sondern als kontrollierter A/B-Test gegen Wan 2.1.

Die Datenlage spricht dafür:

- Wan 2.2 ist besser trainiert.
- TI2V 5B kann Text-to-Video und Image-to-Video.
- 5B ist qualitativ deutlich interessanter als 1.3B.
- Auf deiner RTX A5000 16 GB ist es realistisch — **aber nur mit FP8 / scaled FP8**, nicht bequem mit BF16/FP16.

Der richtige Testpfad ist daher:

```text
Wan 2.1 1.3B FP8 = schneller Iterationsmodus
Wan 2.2 TI2V 5B FP8 scaled = Qualitätsmodus für Kandidaten
```

Nicht:

```text
Wan 2.2 14B / 720p / 24fps / lange Clips
```

Das wäre auf 16 GB VRAM unnötig brutal.

---

# Empfehlung

## Ja, installieren und testen

Aber wir nehmen diese Variante:

```text
Wan2_2-TI2V-5B_fp8_e4m3fn_scaled_KJ.safetensors
```

Größe laut HuggingFace-Listing:

```text
ca. 4.91 GB
```

Nicht zuerst:

```text
Wan2_2-TI2V-5B_fp16.safetensors
```

Die FP16/BF16-Variante liegt bei ca. 9.3 GB. Zusammen mit T5 + VAE + Overhead wird das auf 16 GB schnell eng.

---

# 1. ComfyUI stoppen

Auf dem GPU-Host:

```bash
pkill -f "python main.py"
```

---

# 2. Genug Speicher prüfen

```bash
df -h ~/ai
free -h
```

Für Wan 2.2 Test brauchst du zusätzlich ungefähr:

```text
7–10 GB Download/Cache
```

Besser:

```text
20 GB frei
```

---

# 3. Modelle herunterladen

Venv aktivieren:

```bash
cd ~/ai/ComfyUI
source .venv/bin/activate
```

## Wan 2.2 TI2V 5B FP8 scaled

```bash
mkdir -p ~/ai/ComfyUI/models/diffusion_models/TI2V

hf download Kijai/WanVideo_comfy_fp8_scaled \
  TI2V/Wan2_2-TI2V-5B_fp8_e4m3fn_scaled_KJ.safetensors \
  --local-dir ~/ai/ComfyUI/models/diffusion_models
```

Danach prüfen:

```bash
ls -lh ~/ai/ComfyUI/models/diffusion_models/TI2V/
```

Erwartet:

```text
Wan2_2-TI2V-5B_fp8_e4m3fn_scaled_KJ.safetensors
```

---

## Wan 2.2 VAE

Wan 2.2 nutzt eine andere VAE als Wan 2.1. Bitte laden:

```bash
hf download Kijai/WanVideo_comfy \
  Wan2_2_VAE_bf16.safetensors \
  --local-dir ~/ai/ComfyUI/models/vae
```

Prüfen:

```bash
ls -lh ~/ai/ComfyUI/models/vae/
```

Erwartet zusätzlich:

```text
Wan2_2_VAE_bf16.safetensors
```

Größe ungefähr:

```text
1.3 GB
```

---

## Besserer / passender UMT5 FP8 Text Encoder

Du hast aktuell:

```text
umt5-xxl-enc-fp8_e4m3fn.safetensors
```

Für Wan 2.2 / native Workflows wird oft diese Variante genutzt:

```text
umt5_xxl_fp8_e4m3fn_scaled.safetensors
```

Laden:

```bash
mkdir -p ~/ai/ComfyUI/models/text_encoders

hf download Comfy-Org/Wan_2.2_ComfyUI_Repackaged \
  split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors \
  --local-dir /tmp/wan22_text_encoder
```

Dann kopieren:

```bash
cp /tmp/wan22_text_encoder/split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors \
  ~/ai/ComfyUI/models/text_encoders/
```

Prüfen:

```bash
ls -lh ~/ai/ComfyUI/models/text_encoders/
```

Du solltest dann haben:

```text
umt5-xxl-enc-fp8_e4m3fn.safetensors
umt5_xxl_fp8_e4m3fn_scaled.safetensors
```

---

# 4. ComfyUI neu starten

Bitte wieder **ohne `--lowvram`**:

```bash
cd ~/ai/ComfyUI
source .venv/bin/activate

TS_IP="$(tailscale ip -4 2>/dev/null | head -n1 || true)"
[ -z "$TS_IP" ] && TS_IP="127.0.0.1"

python main.py \
  --listen "$TS_IP" \
  --port 8188 \
  --reserve-vram 1.0
```

Das ist weiterhin unser Standard.

---

# 5. Wenn OOM kommt

Dann zuerst mehr reservieren:

```bash
python main.py \
  --listen "$TS_IP" \
  --port 8188 \
  --reserve-vram 2.0
```

Falls immer noch OOM:

```bash
python main.py \
  --listen "$TS_IP" \
  --port 8188 \
  --reserve-vram 3.0
```

Erst wenn das nicht reicht:

```bash
python main.py \
  --listen "$TS_IP" \
  --port 8188 \
  --lowvram
```

Aber `--lowvram` ist wieder Notfall, weil dann T5/Offload langsam wird.

---

# 6. Prüfen, ob ComfyUI die Modelle sieht

Nach Neustart:

```bash
curl "http://$(tailscale ip -4 | head -n1):8188/system_stats"
```

Und im GUI prüfen:

```text
http://100.101.173.25:8188
```

Im WanVideo Model Loader sollte dann etwas auftauchen wie:

```text
TI2V/Wan2_2-TI2V-5B_fp8_e4m3fn_scaled_KJ.safetensors
```

Im VAE Loader:

```text
Wan2_2_VAE_bf16.safetensors
```

Im T5/Text Encoder Loader:

```text
umt5_xxl_fp8_e4m3fn_scaled.safetensors
```

---

# 7. Testprofil für Wan 2.2 TI2V 5B

Nicht direkt 720p. Wir testen so:

## Probe A — sicherer Start

```text
416x736
25 Frames
12 fps
8 Steps
Wan 2.2 TI2V 5B FP8 scaled
T5 GPU/main_device
VAE Wan2.2
VAE tiling off
```

Ziel:

```text
Läuft stabil?
GPU-Auslastung?
Ist Motiv klarer als Wan 2.1?
```

## Probe B — Qualitätsvergleich

Wenn A läuft:

```text
480x832
33 Frames
12 fps
10–12 Steps
```

Das ist der direkte Vergleich zu unserem bisherigen besten Wan 2.1 Clip.

## Probe C — Kandidat

Wenn B gut aussieht:

```text
576x1024
49 Frames
12 fps
12–16 Steps
```

Noch nicht 720p. Erst schauen, ob Qualität/Speed sinnvoll ist.

---

# 8. Warum nicht sofort 720p 24 FPS?

Weil 720p/24fps zwar im Modellmarketing steht, aber dein echtes Produktionsziel anders ist:

```text
viele Varianten
schnelle Auswahl
Retention-Test
lokales Compositing
Captions/SFX/Mechanism-Layer
```

Für Shorts reicht es völlig, wenn der AI-Clip z.B. in:

```text
480x832 oder 576x1024
```

gut aussieht und danach lokal in:

```text
1080x1920
```

composited/upscaled wird.

720p nativ ist später für finale Winner-Shots interessant, nicht für Prompt-Findung.

---

# Kurzurteil

## Sollen wir Wan 2.2 TI2V 5B testen?

**Ja. Definitiv.**

Aber als:

```text
Wan 2.2 TI2V 5B FP8 scaled
416x736 → 480x832 → 576x1024
```

Nicht als:

```text
FP16/BF16
720p
24fps
lange Clips
```

## Erwartung

Ich erwarte:

- bessere Semantik
- stabilere Objekte
- weniger abstrakte Lichtflächen
- bessere Bewegung
- bessere Ästhetik

Aber:

- langsamer als 1.3B
- mehr VRAM/RAM
- ggf. OOM bei zu hohen Settings

---

# Bitte jetzt ausführen

Kurzform der wichtigsten Befehle:

```bash
cd ~/ai/ComfyUI
source .venv/bin/activate

mkdir -p ~/ai/ComfyUI/models/diffusion_models/TI2V
mkdir -p ~/ai/ComfyUI/models/vae
mkdir -p ~/ai/ComfyUI/models/text_encoders

hf download Kijai/WanVideo_comfy_fp8_scaled \
  TI2V/Wan2_2-TI2V-5B_fp8_e4m3fn_scaled_KJ.safetensors \
  --local-dir ~/ai/ComfyUI/models/diffusion_models

hf download Kijai/WanVideo_comfy \
  Wan2_2_VAE_bf16.safetensors \
  --local-dir ~/ai/ComfyUI/models/vae

hf download Comfy-Org/Wan_2.2_ComfyUI_Repackaged \
  split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors \
  --local-dir /tmp/wan22_text_encoder

cp /tmp/wan22_text_encoder/split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors \
  ~/ai/ComfyUI/models/text_encoders/
```

Dann starten:

```bash
pkill -f "python main.py"

cd ~/ai/ComfyUI
source .venv/bin/activate

TS_IP="$(tailscale ip -4 2>/dev/null | head -n1 || true)"
[ -z "$TS_IP" ] && TS_IP="127.0.0.1"

python main.py \
  --listen "$TS_IP" \
  --port 8188 \
  --reserve-vram 1.0
```

Wenn du danach sagst:

```text
Wan 2.2 läuft
```

prüfe ich von hier `/object_info`, baue den Wan-2.2-Workflow und starte den A/B-Test gegen unseren Wan-2.1-Clip.


[M G] Wan 2.2 läuft


Explanation:
**Planning next steps**

I need to take action now and test the object information models. To do that, I'll use the available tools. It's important to ensure that everything functions correctly, so I'll make sure I'm following the proper steps for this testing process. Got to keep track of all the details while I'm at it. I want to make sure I'm thorough and organized, so nothing gets overlooked. Let's get started!

python - <<'PY'
import json, urllib.request
base='http://100.101.173.25:8188'
data=json.load(urllib.request.urlopen(base+'/system_stats', timeout=10))
print('argv', data['system'].get('argv'))
print('ram_free_gb', round(data['system']['ram_free']/1024**3,2))
d=data['devices'][0]
print('gpu', d['name'])
print('vram_total_gb', round(d['vram_total']/1024**3,2), 'vram_free_gb', round(d['vram_free']/1024**3,2))
obj=json.load(urllib.request.urlopen(base+'/object_info', timeout=20))
for node in ['WanVideoModelLoader','LoadWanVideoT5TextEncoder','WanVideoVAELoader']:
    req=obj[node]['input']['required']
    print('\n##',node)
    for k,v in req.items():
        if isinstance(v, list) and v and isinstance(v[0], list):
            opts=v[0]
            print(k, [o for o in opts if any(s in str(o).lower() for s in ['wan2_2','wan2.2','ti2v','umt5_xxl','vae'])])
        else:
            print(k, str(v)[:120])
PY


Output:
argv ['main.py', '--listen', '100.101.173.25', '--port', '8188', '--reserve-vram', '1.0']
ram_free_gb 17.29
gpu cuda:0 NVIDIA RTX A5000 Laptop GPU : cudaMallocAsync
vram_total_gb 15.61 vram_free_gb 15.36

## WanVideoModelLoader
model ['TI2V/Wan2_2-TI2V-5B_fp8_e4m3fn_scaled_KJ.safetensors']
base_precision []
quantization []
load_device []

## LoadWanVideoT5TextEncoder
model_name ['umt5_xxl_fp8_e4m3fn_scaled.safetensors']
precision []

## WanVideoVAELoader
model_name ['Wan2_1_VAE_bf16.safetensors', 'Wan2_2_VAE_bf16.safetensors']


Explanation:
**Creating a workflow**

I need to develop a workflow for Wan2.2 and consider whether quantization should be scaled. There are different options to inspect, and I want to ensure that I make the right choice. It’s important to evaluation potential methods and assess which will be most effective for the workflow. I’m curious about the implications of quantization scaling and how it might impact overall performance. Let’s dig into the details!

python - <<'PY'
import json, urllib.request
obj=json.load(urllib.request.urlopen('http://100.101.173.25:8188/object_info', timeout=20))
for node in ['WanVideoModelLoader','LoadWanVideoT5TextEncoder','WanVideoEmptyEmbeds','WanVideoSampler']:
 print('\n##', node)
 for group in ['required','optional']:
  print(group)
  for k,v in obj[node]['input'].get(group,{}).items(): print(k, str(v)[:400])
PY


Output:
## WanVideoModelLoader
required
model [['TI2V/Wan2_2-TI2V-5B_fp8_e4m3fn_scaled_KJ.safetensors', 'Wan2_1-T2V-1_3B_fp8_e4m3fn.safetensors'], {'tooltip': "These models are loaded from the 'ComfyUI/models/diffusion_models' -folder"}]
base_precision [['fp32', 'bf16', 'fp16', 'fp16_fast'], {'default': 'bf16'}]
quantization [['disabled', 'fp8_e4m3fn', 'fp8_e4m3fn_fast', 'fp8_e4m3fn_scaled', 'fp8_e4m3fn_scaled_fast', 'fp8_e5m2', 'fp8_e5m2_fast', 'fp8_e5m2_scaled', 'fp8_e5m2_scaled_fast'], {'default': 'disabled', 'tooltip': "Optional quantization method, 'disabled' acts as autoselect based by weights. Scaled modes only work with matching weights, _fast modes (fp8 matmul) require CUDA compute capability >= 8.9 (NVIDIA 4
load_device [['main_device', 'offload_device'], {'default': 'offload_device', 'tooltip': 'Initial device to load the model to, NOT recommended with the larger models unless you have 48GB+ VRAM'}]
optional
attention_mode [['sdpa', 'flash_attn_2', 'flash_attn_3', 'sageattn', 'sageattn_3', 'radial_sage_attention', 'sageattn_compiled', 'sageattn_ultravico', 'comfy'], {'default': 'sdpa'}]
compile_args ['WANCOMPILEARGS']
block_swap_args ['BLOCKSWAPARGS']
lora ['WANVIDLORA', {'default': None}]
vram_management_args ['VRAM_MANAGEMENTARGS', {'default': None, 'tooltip': 'Alternative offloading method from DiffSynth-Studio, more aggressive in reducing memory use than block swapping, but can be slower'}]
extra_model ['VACEPATH', {'default': None, 'tooltip': 'Extra model to add to the main model, ie. VACE or MTV Crafter'}]
fantasytalking_model ['FANTASYTALKINGMODEL', {'default': None, 'tooltip': 'FantasyTalking model https://github.com/Fantasy-AMAP'}]
multitalk_model ['MULTITALKMODEL', {'default': None, 'tooltip': 'Multitalk model'}]
fantasyportrait_model ['FANTASYPORTRAITMODEL', {'default': None, 'tooltip': 'FantasyPortrait model'}]
rms_norm_function [['default', 'pytorch'], {'default': 'default', 'tooltip': "RMSNorm function to use, 'pytorch' is the new native torch RMSNorm, which is faster (when not using torch.compile mostly) but changes results slightly. 'default' is the original WanRMSNorm"}]

## LoadWanVideoT5TextEncoder
required
model_name [['umt5-xxl-enc-fp8_e4m3fn.safetensors', 'umt5_xxl_fp8_e4m3fn_scaled.safetensors'], {'tooltip': "These models are loaded from 'ComfyUI/models/text_encoders'"}]
precision [['fp32', 'bf16'], {'default': 'bf16'}]
optional
load_device [['main_device', 'offload_device'], {'default': 'offload_device'}]
quantization [['disabled', 'fp8_e4m3fn'], {'default': 'disabled', 'tooltip': 'optional quantization method'}]

## WanVideoEmptyEmbeds
required
width ['INT', {'default': 832, 'min': 64, 'max': 8096, 'step': 8, 'tooltip': 'Width of the image to encode'}]
height ['INT', {'default': 480, 'min': 64, 'max': 8096, 'step': 8, 'tooltip': 'Height of the image to encode'}]
num_frames ['INT', {'default': 81, 'min': 1, 'max': 10000, 'step': 4, 'tooltip': 'Number of frames to encode'}]
optional
control_embeds ['WANVIDIMAGE_EMBEDS', {'tooltip': 'control signal for the Fun -model'}]
extra_latents ['LATENT', {'tooltip': 'First latent to use for the Pusa -model'}]

## WanVideoSampler
required
model ['WANVIDEOMODEL']
image_embeds ['WANVIDIMAGE_EMBEDS']
steps ['INT', {'default': 30, 'min': 1}]
cfg ['FLOAT', {'default': 6.0, 'min': 0.0, 'max': 30.0, 'step': 0.01}]
shift ['FLOAT', {'default': 5.0, 'min': 0.0, 'max': 1000.0, 'step': 0.01}]
seed ['INT', {'default': 0, 'min': 0, 'max': 18446744073709551615}]
force_offload ['BOOLEAN', {'default': True, 'tooltip': 'Moves the model to the offload device after sampling'}]
scheduler [['unipc', 'unipc/beta', 'dpm++', 'dpm++/beta', 'dpm++_sde', 'dpm++_sde/beta', 'euler', 'euler/beta', 'longcat_distill_euler', 'deis', 'lcm', 'lcm/beta', 'res_multistep', 'er_sde', 'flowmatch_causvid', 'flowmatch_distill', 'flowmatch_pusa', 'multitalk', 'sa_ode_stable', 'rcm', 'vibt_unipc'], {'default': 'unipc'}]
riflex_freq_index ['INT', {'default': 0, 'min': 0, 'max': 1000, 'step': 1, 'tooltip': 'Frequency index for RIFLEX, disabled when 0, default 6. Allows for new frames to be generated after without looping'}]
optional
text_embeds ['WANVIDEOTEXTEMBEDS']
samples ['LATENT', {'tooltip': 'init Latents to use for video2video process'}]
denoise_strength ['FLOAT', {'default': 1.0, 'min': 0.0, 'max': 1.0, 'step': 0.01}]
feta_args ['FETAARGS']
context_options ['WANVIDCONTEXT']
cache_args ['CACHEARGS']
flowedit_args ['FLOWEDITARGS', {'tooltip': 'FlowEdit support has been deprecated'}]
batched_cfg ['BOOLEAN', {'default': False, 'tooltip': 'Batch cond and uncond for faster sampling, possibly faster on some hardware, uses more memory'}]
slg_args ['SLGARGS']
rope_function [['default', 'comfy', 'comfy_chunked'], {'default': 'comfy', 'tooltip': "Comfy's RoPE implementation doesn't use complex numbers and can thus be compiled, that should be a lot faster when using torch.compile. Chunked version has reduced peak VRAM usage when not using torch.compile"}]
loop_args ['LOOPARGS']
experimental_args ['EXPERIMENTALARGS']
sigmas ['SIGMAS']
unianimate_poses ['UNIANIMATE_POSE']
fantasytalking_embeds ['FANTASYTALKING_EMBEDS']
uni3c_embeds ['UNI3C_EMBEDS']
multitalk_embeds ['MULTITALK_EMBEDS']
freeinit_args ['FREEINITARGS']
start_step ['INT', {'default': 0, 'min': 0, 'max': 10000, 'step': 1, 'tooltip': 'Start step for the sampling, 0 means full sampling, otherwise samples only from this step'}]
end_step ['INT', {'default': -1, 'min': -1, 'max': 10000, 'step': 1, 'tooltip': 'End step for the sampling, -1 means full sampling, otherwise samples only until this step'}]
add_noise_to_samples ['BOOLEAN', {'default': False, 'tooltip': 'Add noise to the samples before sampling, needed for video2video sampling when starting from clean video'}]


Vertical realistic cinematic documentary video. A cheap used red compact car in a dim independent garage at night, close-up from the front corner of the car. The camera slowly pushes in toward the headlight and hood. Subtle red warning light reflection, realistic car paint, dramatic shadows, shallow depth of field, high contrast, clean dark background, serious investigation mood. No readable text, no subtitles, no logo, no watermark, negative space for captions.

readable text, subtitles, logos, watermark, fake UI, distorted car, deformed vehicle, extra wheels, cartoon, anime, static image, abstract colors, flickering lights only, blurry, low detail, melting shapes


python - <<'PY'
import json, urllib.request
base='http://100.101.173.25:8188'
workflow=json.load(open('data/comfyui_wan22_scene01_416x736_workflow.json'))
payload=json.dumps({'prompt': workflow, 'client_id': 'hermes-autoshorts-wan22-scene01-416'}).encode()
req=urllib.request.Request(base+'/prompt', data=payload, headers={'Content-Type':'application/json'})
try:
    print(urllib.request.urlopen(req, timeout=30).read().decode())
except Exception as e:
    print('ERROR', type(e).__name__, e)
    if hasattr(e, 'read'):
        print(e.read().decode())
PY


Output: {"prompt_id": "0811ef54-61ac-447f-8caf-74156b60a387", "number": 0, "node_errors": {}}


python - <<'PY'
import json, time, urllib.request
base='http://100.101.173.25:8188'
pid='0811ef54-61ac-447f-8caf-74156b60a387'
for i in range(180):
    q=json.load(urllib.request.urlopen(base+'/queue', timeout=10))
    s=json.load(urllib.request.urlopen(base+'/system_stats', timeout=10))
    running=len(q.get('queue_running', [])); pending=len(q.get('queue_pending', []))
    d=s['devices'][0]
    vused=(d['vram_total']-d['vram_free'])/1024**3
    print(f'poll {i:03d}: running={running} pending={pending} vram_used_gb={vused:.2f} ram_free_gb={s["system"]["ram_free"]/1024**3:.2f}')
    if not running and not pending:
        break
    time.sleep(5)
h=json.load(urllib.request.urlopen(base+'/history/'+pid, timeout=20))
print('STATUS')
print(json.dumps(h.get(pid, {}).get('status',{}), indent=2)[:5000])
print('OUTPUTS')
print(json.dumps(h.get(pid, {}).get('outputs',{}), indent=2))
PY


Output:
poll 000: running=0 pending=0 vram_used_gb=0.27 ram_free_gb=16.44
STATUS
{
  "status_str": "error",
  "completed": false,
  "messages": [
    [
      "execution_start",
      {
        "prompt_id": "0811ef54-61ac-447f-8caf-74156b60a387",
        "timestamp": 1779555440591
      }
    ],
    [
      "execution_cached",
      {
        "nodes": [],
        "prompt_id": "0811ef54-61ac-447f-8caf-74156b60a387",
        "timestamp": 1779555440596
      }
    ],
    [
      "execution_error",
      {
        "prompt_id": "0811ef54-61ac-447f-8caf-74156b60a387",
        "node_id": "2",
        "node_type": "LoadWanVideoT5TextEncoder",
        "executed": [
          "1"
        ],
        "exception_message": "Invalid T5 text encoder model, fp8 scaled is not supported by this node\n",
        "exception_type": "ValueError",
        "traceback": [
          "  File \"/home/gam/ai/ComfyUI/execution.py\", line 536, in execute\n    output_data, output_ui, has_subgraph, has_pending_tasks = await get_output_data(prompt_id, unique_id, obj, input_data_all, execution_block_cb=execution_block_cb, pre_execute_cb=pre_execute_cb, v3_data=v3_data)\n                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/execution.py\", line 336, in get_output_data\n    return_values = await _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, obj.FUNCTION, allow_interrupt=True, execution_block_cb=execution_block_cb, pre_execute_cb=pre_execute_cb, v3_data=v3_data)\n                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/execution.py\", line 310, in _async_map_node_over_list\n    await process_inputs(input_dict, i)\n",
          "  File \"/home/gam/ai/ComfyUI/execution.py\", line 298, in process_inputs\n    result = f(**inputs)\n             ^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/custom_nodes/ComfyUI-WanVideoWrapper/nodes_model_loading.py\", line 1992, in loadmodel\n    raise ValueError(\"Invalid T5 text encoder model, fp8 scaled is not supported by this node\")\n"
        ],
        "current_inputs": {
          "model_name": [
            "umt5_xxl_fp8_e4m3fn_scaled.safetensors"
          ],
          "precision": [
            "bf16"
          ],
          "load_device": [
            "main_device"
          ],
          "quantization": [
            "fp8_e4m3fn"
          ]
        },
        "current_outputs": [
          "3",
          "4",
          "6",
          "8",
          "5",
          "1",
          "9",
          "7",
          "2"
        ],
        "timestamp": 1779555441148
      }
    ]
  ]
}
OUTPUTS
{}


Explanation:
**Adjusting text encoder**

I realize I need to adjust the text encoder to the unscaled original version, or maybe the node doesn't support the scaled option. It seems like using the current old text encoder with quantization disabled is the way to go. I just have to retry this approach. Let's see if that's the solution to the issue I'm facing. Fingers crossed!

python - <<'PY'
from pathlib import Path
p=Path('data/comfyui_wan22_scene01_416x736_workflow.json')
s=p.read_text()
s=s.replace('"model_name": "umt5_xxl_fp8_e4m3fn_scaled.safetensors"','"model_name": "umt5-xxl-enc-fp8_e4m3fn.safetensors"')
s=s.replace('"quantization": "fp8_e4m3fn"\n    }\n  },\n  "3"', '"quantization": "disabled"\n    }\n  },\n  "3"')
s=s.replace('"filename_prefix": "autoshorts_wan22_scene01_416x736"','"filename_prefix": "autoshorts_wan22_scene01_416x736_t5legacy"')
p2=Path('data/comfyui_wan22_scene01_416x736_t5legacy_workflow.json')
p2.write_text(s)
print(p2)
PY


python - <<'PY'
import json, urllib.request
base='http://100.101.173.25:8188'
workflow=json.load(open('data/comfyui_wan22_scene01_416x736_t5legacy_workflow.json'))
payload=json.dumps({'prompt': workflow, 'client_id': 'hermes-autoshorts-wan22-scene01-416-t5legacy'}).encode()
req=urllib.request.Request(base+'/prompt', data=payload, headers={'Content-Type':'application/json'})
print(urllib.request.urlopen(req, timeout=30).read().decode())
PY


Output: {"prompt_id": "7278cb34-e3ae-4a9f-9cf4-8b468589ffc9", "number": 1, "node_errors": {}}


python - <<'PY'
import json, time, urllib.request, urllib.error
base='http://100.101.173.25:8188'
pid='7278cb34-e3ae-4a9f-9cf4-8b468589ffc9'
for i in range(180):
    q=json.load(urllib.request.urlopen(base+'/queue', timeout=10))
    s=json.load(urllib.request.urlopen(base+'/system_stats', timeout=10))
    running=len(q.get('queue_running', [])); pending=len(q.get('queue_pending', []))
    d=s['devices'][0]
    vused=(d['vram_total']-d['vram_free'])/1024**3
    print(f'poll {i:03d}: running={running} pending={pending} vram_used_gb={vused:.2f} ram_free_gb={s["system"]["ram_free"]/1024**3:.2f}')
    if not running and not pending:
        break
    time.sleep(5)
h=json.load(urllib.request.urlopen(base+'/history/'+pid, timeout=20))
print('STATUS')
print(json.dumps(h.get(pid, {}).get('status',{}), indent=2)[:5000])
print('OUTPUTS')
print(json.dumps(h.get(pid, {}).get('outputs',{}), indent=2))
PY


Output:
poll 000: running=1 pending=0 vram_used_gb=7.83 ram_free_gb=16.04
poll 001: running=1 pending=0 vram_used_gb=11.41 ram_free_gb=16.03
poll 002: running=1 pending=0 vram_used_gb=11.42 ram_free_gb=16.05
poll 003: running=1 pending=0 vram_used_gb=11.45 ram_free_gb=16.01
poll 004: running=1 pending=0 vram_used_gb=11.45 ram_free_gb=15.97
poll 005: running=1 pending=0 vram_used_gb=11.38 ram_free_gb=14.15
poll 006: running=0 pending=0 vram_used_gb=13.42 ram_free_gb=15.21
STATUS
{
  "status_str": "error",
  "completed": false,
  "messages": [
    [
      "execution_start",
      {
        "prompt_id": "7278cb34-e3ae-4a9f-9cf4-8b468589ffc9",
        "timestamp": 1779555466911
      }
    ],
    [
      "execution_cached",
      {
        "nodes": [
          "1"
        ],
        "prompt_id": "7278cb34-e3ae-4a9f-9cf4-8b468589ffc9",
        "timestamp": 1779555466913
      }
    ],
    [
      "execution_error",
      {
        "prompt_id": "7278cb34-e3ae-4a9f-9cf4-8b468589ffc9",
        "node_id": "7",
        "node_type": "WanVideoDecode",
        "executed": [
          "3",
          "4",
          "6",
          "5",
          "2"
        ],
        "exception_message": "Allocation on device 0 would exceed allowed memory. (out of memory)\nCurrently allocated     : 14.61 GiB\nRequested               : 455.27 MiB\nDevice limit            : 15.61 GiB\nFree (according to CUDA): 9.19 MiB\nPyTorch limit (set by user-supplied memory fraction)\n                        : 17179869184.00 GiB\nThis error means you ran out of memory on your GPU.\n\nTIPS: If the workflow worked before you might have accidentally set the batch_size to a large number.",
        "exception_type": "torch.OutOfMemoryError",
        "traceback": [
          "  File \"/home/gam/ai/ComfyUI/execution.py\", line 536, in execute\n    output_data, output_ui, has_subgraph, has_pending_tasks = await get_output_data(prompt_id, unique_id, obj, input_data_all, execution_block_cb=execution_block_cb, pre_execute_cb=pre_execute_cb, v3_data=v3_data)\n                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/execution.py\", line 336, in get_output_data\n    return_values = await _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, obj.FUNCTION, allow_interrupt=True, execution_block_cb=execution_block_cb, pre_execute_cb=pre_execute_cb, v3_data=v3_data)\n                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/execution.py\", line 310, in _async_map_node_over_list\n    await process_inputs(input_dict, i)\n",
          "  File \"/home/gam/ai/ComfyUI/execution.py\", line 298, in process_inputs\n    result = f(**inputs)\n             ^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/custom_nodes/ComfyUI-WanVideoWrapper/nodes.py\", line 2149, in decode\n    images = vae.decode(latents, device=device, end_=(end_image is not None), tiled=enable_vae_tiling, tile_size=(tile_x//8, tile_y//8), tile_stride=(tile_stride_x//8, tile_stride_y//8))[0]\n             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/custom_nodes/ComfyUI-WanVideoWrapper/wanvideo/wan_video_vae.py\", line 1417, in decode\n    video = self.single_decode(hidden_state, device, pbar=pbar)\n            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/custom_nodes/ComfyUI-WanVideoWrapper/wanvideo/wan_video_vae.py\", line 1371, in single_decode\n    video = self.model.decode(hidden_state, pbar=pbar)\n            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/custom_nodes/ComfyUI-WanVideoWrapper/wanvideo/wan_video_vae.py\", line 1521, in decode\n    out_ = self.decoder(x[:, :, i:i + 1, :, :],\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/.venv/lib/python3.12/site-packages/torch/nn/modules/module.py\", line 1778, in _wrapped_call_impl\n    return self._call_impl(*args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/.venv/lib/python3.12/site-packages/torch/nn/modules/module.py\", line 1789, in _call_impl\n    return forward_call(*args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/custom_nodes/ComfyUI-WanVideoWrapper/wanvideo/wan_video_vae.py\", line 944, in forward\n    x = layer(x, feat_cache, feat_idx, first_chunk)\n        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/.venv/lib/python3.12/site-packages/torch/nn/modules/module.py\", line 1778, in _wrapped_call_impl\n    return self._call_impl(*args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/ComfyUI/.venv/lib/python3.12/site-packages/torch/nn/modules/module.py\", line 1789, in _call_impl\n    return forward_call(*args, **kwargs)\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
          "  File \"/home/gam/ai/Comfy
OUTPUTS
{}


python - <<'PY'
import urllib.request, json
base='http://100.101.173.25:8188'
req=urllib.request.Request(base+'/free', data=json.dumps({'unload_models': False, 'free_memory': True}).encode(), headers={'Content-Type':'application/json'})
try: print(urllib.request.urlopen(req, timeout=10).read().decode())
except Exception as e: print(type(e).__name__, e)
PY


python - <<'PY'
from pathlib import Path
import json
p=Path('data/comfyui_wan22_scene01_416x736_t5legacy_workflow.json')
w=json.loads(p.read_text())
w['3']['inputs']['force_offload']=True
w['5']['inputs']['force_offload']=True
w['7']['inputs']['enable_vae_tiling']=True
w['7']['inputs']['tile_x']=256
w['7']['inputs']['tile_y']=256
w['7']['inputs']['tile_stride_x']=128
w['7']['inputs']['tile_stride_y']=128
w['9']['inputs']['filename_prefix']='autoshorts_wan22_scene01_416x736_tiled'
out=Path('data/comfyui_wan22_scene01_416x736_tiled_workflow.json')
out.write_text(json.dumps(w, indent=2))
print(out)
PY


Output: data/comfyui_wan22_scene01_416x736_tiled_workflow.json


python - <<'PY'
import json, urllib.request
base='http://100.101.173.25:8188'
workflow=json.load(open('data/comfyui_wan22_scene01_416x736_tiled_workflow.json'))
payload=json.dumps({'prompt': workflow, 'client_id': 'hermes-autoshorts-wan22-scene01-416-tiled'}).encode()
req=urllib.request.Request(base+'/prompt', data=payload, headers={'Content-Type':'application/json'})
print(urllib.request.urlopen(req, timeout=30).read().decode())
PY


Output: {"prompt_id": "69b5a4b9-b276-4a06-a45e-549f71931b69", "number": 2, "node_errors": {}}


python - <<'PY'
import json, time, urllib.request
base='http://100.101.173.25:8188'
pid='69b5a4b9-b276-4a06-a45e-549f71931b69'
for i in range(180):
    q=json.load(urllib.request.urlopen(base+'/queue', timeout=10))
    s=json.load(urllib.request.urlopen(base+'/system_stats', timeout=10))
    running=len(q.get('queue_running', [])); pending=len(q.get('queue_pending', []))
    d=s['devices'][0]
    vused=(d['vram_total']-d['vram_free'])/1024**3
    print(f'poll {i:03d}: running={running} pending={pending} vram_used_gb={vused:.2f} ram_free_gb={s["system"]["ram_free"]/1024**3:.2f}')
    if not running and not pending:
        break
    time.sleep(5)
h=json.load(urllib.request.urlopen(base+'/history/'+pid, timeout=20))
print('STATUS')
print(json.dumps(h.get(pid, {}).get('status',{}), indent=2)[:6000])
print('OUTPUTS')
print(json.dumps(h.get(pid, {}).get('outputs',{}), indent=2))
PY


Output:
poll 000: running=1 pending=0 vram_used_gb=5.23 ram_free_gb=15.59
poll 001: running=1 pending=0 vram_used_gb=5.18 ram_free_gb=15.59
poll 002: running=1 pending=0 vram_used_gb=5.13 ram_free_gb=15.56
poll 003: running=1 pending=0 vram_used_gb=5.17 ram_free_gb=15.55
poll 004: running=1 pending=0 vram_used_gb=5.18 ram_free_gb=15.53
poll 005: running=1 pending=0 vram_used_gb=0.36 ram_free_gb=13.76
poll 006: running=1 pending=0 vram_used_gb=2.48 ram_free_gb=15.14
poll 007: running=1 pending=0 vram_used_gb=1.71 ram_free_gb=15.19
poll 008: running=1 pending=0 vram_used_gb=2.37 ram_free_gb=15.26
poll 009: running=1 pending=0 vram_used_gb=2.44 ram_free_gb=15.31
poll 010: running=1 pending=0 vram_used_gb=1.71 ram_free_gb=15.35
poll 011: running=0 pending=0 vram_used_gb=0.36 ram_free_gb=14.37
STATUS
{
  "status_str": "success",
  "completed": true,
  "messages": [
    [
      "execution_start",
      {
        "prompt_id": "69b5a4b9-b276-4a06-a45e-549f71931b69",
        "timestamp": 1779555534590
      }
    ],
    [
      "execution_cached",
      {
        "nodes": [],
        "prompt_id": "69b5a4b9-b276-4a06-a45e-549f71931b69",
        "timestamp": 1779555534592
      }
    ],
    [
      "execution_success",
      {
        "prompt_id": "69b5a4b9-b276-4a06-a45e-549f71931b69",
        "timestamp": 1779555598321
      }
    ]
  ]
}
OUTPUTS
{
  "9": {
    "images": [
      {
        "filename": "autoshorts_wan22_scene01_416x736_tiled_00001_.mp4",
        "subfolder": "",
        "type": "output"
      }
    ],
    "animated": [
      true
    ]
  }
}


python - <<'PY'
import urllib.parse, urllib.request, pathlib
base='http://100.101.173.25:8188'
fn='autoshorts_wan22_scene01_416x736_tiled_00001_.mp4'
params=urllib.parse.urlencode({'filename':fn,'subfolder':'','type':'output'})
out=pathlib.Path('/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/'+fn)
out.parent.mkdir(parents=True, exist_ok=True)
out.write_bytes(urllib.request.urlopen(base+'/view?'+params, timeout=120).read())
print(out, out.stat().st_size)
PY
ffprobe -v error -select_streams v:0 -show_entries stream=width,height,avg_frame_rate,duration -of default=nw=1:nk=1 data/comfyui_outputs/autoshorts_wan22_scene01_416x736_tiled_00001_.mp4
ffmpeg -y -i data/comfyui_outputs/autoshorts_wan22_scene01_416x736_tiled_00001_.mp4 -vf "select=eq(n\,12)" -frames:v 1 /tmp/autoshorts_comfy_check/wan22_scene01_416_mid.jpg >/dev/null 2>&1 && ls -lh /tmp/autoshorts_comfy_check/wan22_scene01_416_mid.jpg


Output:
/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/autoshorts_wan22_scene01_416x736_tiled_00001_.mp4 71060
416
736
12/1
2.083333
-rw-rw-r-- 1 agent agent 9,8K Mai 23 19:00 /tmp/autoshorts_comfy_check/wan22_scene01_416_mid.jpg


Question: Beurteile knapp den Frame: Ist ein Auto/Garagenmotiv klar erkennbar? Wirkt Wan2.2 TI2V 5B besser als der vorherige Wan2.1-Clip oder noch artefaktisch? Eignet sich das als B-Roll?


Image loaded into your context — you can see it natively now. Use your built-in vision to answer the user.

Question: Beurteile knapp den Frame: Ist ein Auto/Garagenmotiv klar erkennbar? Wirkt Wan2.2 TI2V 5B besser als der vorherige Wan2.1-Clip oder noch artefaktisch? Eignet sich das als B-Roll?


Vertical realistic cinematic documentary video. A clearly visible red used compact car parked in a clean inspection garage under bright overhead lights. Full front three-quarter view of the car, hood and headlights visible, mechanic inspection mood, camera slowly pushes forward toward the car. Realistic car paint, sharp details, balanced exposure, cinematic contrast, shallow depth of field, clean background, no readable text, no subtitles, no logo, no watermark, negative space for captions.

dark underexposed image, black frame, unreadable silhouette, readable text, subtitles, logos, watermark, fake UI, distorted car, deformed vehicle, extra wheels, cartoon, anime, static image, abstract colors, flickering lights only, blurry, low detail, melting shapes


python - <<'PY'
import json, urllib.request
base='http://100.101.173.25:8188'
# free memory first
req=urllib.request.Request(base+'/free', data=json.dumps({'unload_models': False, 'free_memory': True}).encode(), headers={'Content-Type':'application/json'})
urllib.request.urlopen(req, timeout=10).read()
workflow=json.load(open('data/comfyui_wan22_scene01_bright_416x736_workflow.json'))
payload=json.dumps({'prompt': workflow, 'client_id': 'hermes-autoshorts-wan22-scene01-bright'}).encode()
req=urllib.request.Request(base+'/prompt', data=payload, headers={'Content-Type':'application/json'})
print(urllib.request.urlopen(req, timeout=30).read().decode())
PY


Output: {"prompt_id": "a4fc65ff-0791-41c0-8730-ffdb026653d8", "number": 3, "node_errors": {}}


python - <<'PY'
import json, time, urllib.request
base='http://100.101.173.25:8188'
pid='a4fc65ff-0791-41c0-8730-ffdb026653d8'
for i in range(180):
    q=json.load(urllib.request.urlopen(base+'/queue', timeout=10))
    s=json.load(urllib.request.urlopen(base+'/system_stats', timeout=10))
    running=len(q.get('queue_running', [])); pending=len(q.get('queue_pending', []))
    d=s['devices'][0]
    vused=(d['vram_total']-d['vram_free'])/1024**3
    print(f'poll {i:03d}: running={running} pending={pending} vram_used_gb={vused:.2f} ram_free_gb={s["system"]["ram_free"]/1024**3:.2f}')
    if not running and not pending:
        break
    time.sleep(5)
h=json.load(urllib.request.urlopen(base+'/history/'+pid, timeout=20))
print('STATUS')
print(json.dumps(h.get(pid, {}).get('status',{}), indent=2)[:5000])
print('OUTPUTS')
print(json.dumps(h.get(pid, {}).get('outputs',{}), indent=2))
PY


Output:
poll 000: running=0 pending=0 vram_used_gb=0.36 ram_free_gb=7.76
STATUS
{
  "status_str": "success",
  "completed": true,
  "messages": [
    [
      "execution_start",
      {
        "prompt_id": "a4fc65ff-0791-41c0-8730-ffdb026653d8",
        "timestamp": 1779555647869
      }
    ],
    [
      "execution_cached",
      {
        "nodes": [],
        "prompt_id": "a4fc65ff-0791-41c0-8730-ffdb026653d8",
        "timestamp": 1779555647871
      }
    ],
    [
      "execution_success",
      {
        "prompt_id": "a4fc65ff-0791-41c0-8730-ffdb026653d8",
        "timestamp": 1779555766864
      }
    ]
  ]
}
OUTPUTS
{
  "9": {
    "images": [
      {
        "filename": "autoshorts_wan22_scene01_bright_416x736_00001_.mp4",
        "subfolder": "",
        "type": "output"
      }
    ],
    "animated": [
      true
    ]
  }
}


Explanation:
**Analyzing the queue process**

I’ve noticed an interesting pattern with the queue. It took a while between the prompt and the poll, and I realize we didn’t monitor it because it got queued after the previous task. Maybe we waited too long before analyzing it? I'll look into downloading and analyzing the data to understand what happened better. It seems I need to clarify how we’re managing these queues going forward!

python - <<'PY'
import urllib.parse, urllib.request, pathlib
base='http://100.101.173.25:8188'
fn='autoshorts_wan22_scene01_bright_416x736_00001_.mp4'
params=urllib.parse.urlencode({'filename':fn,'subfolder':'','type':'output'})
out=pathlib.Path('/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/'+fn)
out.parent.mkdir(parents=True, exist_ok=True)
out.write_bytes(urllib.request.urlopen(base+'/view?'+params, timeout=120).read())
print(out, out.stat().st_size)
PY
ffprobe -v error -select_streams v:0 -show_entries stream=width,height,avg_frame_rate,duration -of default=nw=1:nk=1 data/comfyui_outputs/autoshorts_wan22_scene01_bright_416x736_00001_.mp4
ffmpeg -y -i data/comfyui_outputs/autoshorts_wan22_scene01_bright_416x736_00001_.mp4 -vf "select=eq(n\,12)" -frames:v 1 /tmp/autoshorts_comfy_check/wan22_scene01_bright_mid.jpg >/dev/null 2>&1 && ls -lh /tmp/autoshorts_comfy_check/wan22_scene01_bright_mid.jpg


Output:
/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/autoshorts_wan22_scene01_bright_416x736_00001_.mp4 107965
416
736
12/1
2.083333
-rw-rw-r-- 1 agent agent 24K Mai 23 19:08 /tmp/autoshorts_comfy_check/wan22_scene01_bright_mid.jpg


Question: Beurteile knapp: Ist ein Auto klar erkennbar? Ist der Clip heller/brauchbarer als der vorherige dunkle Wan2.2-Test und als B-Roll geeignet?


Image loaded into your context — you can see it natively now. Use your built-in vision to answer the user.

Question: Beurteile knapp: Ist ein Auto klar erkennbar? Ist der Clip heller/brauchbarer als der vorherige dunkle Wan2.2-Test und als B-Roll geeignet?


Ja, Sir — **Wan 2.2 TI2V 5B läuft jetzt und ist sichtbar besser.**

Ich habe direkt drei Dinge getestet:

## 1. Modell/ComfyUI erkannt

ComfyUI sieht jetzt:

```text
TI2V/Wan2_2-TI2V-5B_fp8_e4m3fn_scaled_KJ.safetensors
Wan2_2_VAE_bf16.safetensors
umt5_xxl_fp8_e4m3fn_scaled.safetensors
```

GPU-Host:

```text
ComfyUI: --reserve-vram 1.0
VRAM frei vor Job: ca. 15.36 GB
RAM frei: ca. 17.29 GB
```

Der Startbefehl bleibt also korrekt:

```bash
cd ~/ai/ComfyUI
source .venv/bin/activate

TS_IP="$(tailscale ip -4 2>/dev/null | head -n1 || true)"
[ -z "$TS_IP" ] && TS_IP="127.0.0.1"

python main.py \
  --listen "$TS_IP" \
  --port 8188 \
  --reserve-vram 1.0
```

---

## 2. Wichtige Erkenntnis: scaled T5 geht im Kijai-Wrapper nicht

Der erste Wan-2.2-Test ist sofort sauber fehlgeschlagen mit:

```text
Invalid T5 text encoder model, fp8 scaled is not supported by this node
```

Also für **Kijai WanVideoWrapper** aktuell nicht verwenden:

```text
umt5_xxl_fp8_e4m3fn_scaled.safetensors
```

Stattdessen nutzen:

```text
umt5-xxl-enc-fp8_e4m3fn.safetensors
```

Das ist wichtig. Die KI-Info war für native ComfyUI-Wan korrekt, aber **nicht für diesen Wrapper-Node**. Natürlich. Zwei Wan-Implementierungen, zwei Wahrheiten. Herrlich effizient.

---

## 3. Zweite Erkenntnis: Wan2.2 braucht VAE tiling auf 16 GB

Test ohne VAE tiling:

```text
416x736
25 Frames
8 Steps
```

Sampling lief, aber Decode starb mit:

```text
torch.OutOfMemoryError
Requested: 455 MiB
Currently allocated: 14.61 GiB
Device limit: 15.61 GiB
```

Fix:

```text
WanVideoDecode enable_vae_tiling = true
tile_x = 256
tile_y = 256
tile_stride_x = 128
tile_stride_y = 128
```

Damit läuft es stabil.

---

# Erfolgreicher Wan2.2-Test

## Dunkler Test

Settings:

```text
Wan2.2 TI2V 5B FP8 scaled
416x736
25 Frames
12 fps
8 Steps
T5 GPU
VAE Wan2.2
VAE tiling on
```

Status:

```text
success
```

Output:

```text
data/comfyui_outputs/autoshorts_wan22_scene01_416x736_tiled_00001_.mp4
```

Video:

MEDIA:/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/autoshorts_wan22_scene01_416x736_tiled_00001_.mp4

Bewertung: zu dunkel, aber strukturell stabiler als Wan2.1.

---

# Besserer Wan2.2-Test: hellerer Prompt

Ich habe den Prompt angepasst:

```text
clearly visible red used compact car
clean inspection garage
bright overhead lights
full front three-quarter view
balanced exposure
```

Settings:

```text
Wan2.2 TI2V 5B FP8 scaled
416x736
25 Frames
12 fps
12 Steps
T5: umt5-xxl-enc-fp8_e4m3fn.safetensors
T5 device: gpu
Wan model: main_device
VAE: Wan2_2_VAE_bf16
VAE tiling: on
```

Status:

```text
success
```

Output:

```text
data/comfyui_outputs/autoshorts_wan22_scene01_bright_416x736_00001_.mp4
```

Technische Werte:

```text
width: 416
height: 736
fps: 12
duration: 2.083s
```

Video:

MEDIA:/home/agent/jarvis_runtime/AutoShortsBot/data/comfyui_outputs/autoshorts_wan22_scene01_bright_416x736_00001_.mp4

Visuelle Bewertung:

```text
Auto klar erkennbar
heller, sauberer, deutlich brauchbarer
als B-Roll-Grundlage geeignet
```

Der Frame zeigt klar ein rotes Auto in einer Garage/Inspection Bay. Nicht perfekt — Kennzeichen/Text muss später ggf. vermieden/verdeckt werden — aber **um Welten besser als blinkende Farben**.

---

# Neuer Wan2.2-Standard für deine A5000

## Startbefehl

```bash
cd ~/ai/ComfyUI
source .venv/bin/activate

TS_IP="$(tailscale ip -4 2>/dev/null | head -n1 || true)"
[ -z "$TS_IP" ] && TS_IP="127.0.0.1"

python main.py \
  --listen "$TS_IP" \
  --port 8188 \
  --reserve-vram 1.0
```

## Workflow-Profil

```text
model:
  TI2V/Wan2_2-TI2V-5B_fp8_e4m3fn_scaled_KJ.safetensors

model quantization:
  fp8_e4m3fn_scaled

text encoder:
  umt5-xxl-enc-fp8_e4m3fn.safetensors

do NOT use with Kijai wrapper:
  umt5_xxl_fp8_e4m3fn_scaled.safetensors

vae:
  Wan2_2_VAE_bf16.safetensors

vae tiling:
  enabled

resolution:
  416x736 for fast preview
  480x832 next quality test

frames:
  25 preview
  33 candidate

fps:
  12

steps:
  12 for preview
  16 later for better candidate
```

---

# Urteil: Wan2.2 vs Wan2.1

## Wan2.1 1.3B

Gut für:

```text
schnelle Iteration
Prompt-Roughcuts
technische Tests
```

Aber Bildqualität/Semantik schwach.

## Wan2.2 TI2V 5B

Gut für:

```text
echte Clip-Kandidaten
bessere Objektklarheit
bessere Garage/Auto-Semantik
brauchbare B-Roll
```

Langsamer und braucht tiling, aber lohnt sich.

---

# Meine Empfehlung ab jetzt

## Pipeline-Entscheidung

```text
Wan2.1 1.3B = Smoke Test / schnelle Prompt-Vorabprüfung
Wan2.2 TI2V 5B = echter Produktionskandidat
```

## Nächster Schritt

Ich würde jetzt den AutoShortsBot-ComfyUI-Client bauen mit zwei Presets:

```text
wan21_fast_preview
wan22_quality_preview
```

Und dann automatisch erzeugen:

```text
scene_01_seed_1.mp4
scene_01_seed_2.mp4
scene_01_seed_3.mp4
```

Für Wan2.2 würde ich als nächstes testen:

```text
480x832
33 Frames
12 fps
12 Steps
VAE tiling on
```

Wenn das läuft und besser aussieht, nehmen wir Wan2.2 als Hauptquelle für die realistischen AI-B-Roll-Clips.

Kurz: **Ja, Wan2.2 lohnt sich. Der helle 416×736-Test ist der erste wirklich brauchbare lokale Clip.**


[M G] diese testclips sind total unbrauchbar. auf dem ersten video ist nichts zu erkennen, ganz dunkel irgendwelche flackernden farben. beim zweiten ein verschwommenes Auto von vorne mit unlesbarem nummernschild... schrecklich. hier ein paar analysen der KI zu den Meldungen aus dem Terminal: 23.05.2026, 18:19 Schweizer Zeit

Ja — Wan 2.2 läuft bei dir grundsätzlich, aber dein aktueller Workflow ist noch nicht optimal. Die Logs zeigen drei Dinge:

## 1. Erster Fehler: falscher T5-Encoder für WanVideoWrapper

Invalid T5 text encoder model, fp8 scaled is not supported by this node

Das ist ein bekannter Konflikt: Der native ComfyUI-Wan2.2-Workflow verwendet offiziell umt5_xxl_fp8_e4m3fn_scaled.safetensors, aber der Kijai WanVideoWrapper T5-Node unterstützt genau diese “fp8 scaled”-Variante nicht sauber. ComfyUIs offizielle Wan2.2-Doku listet für den nativen 5B-Workflow genau diesen scaled Text-Encoder, während GitHub-Issues zum WanVideoWrapper denselben Fehler mit fp8 scaled is not supported zeigen. ([docs.comfy.org][1])

Lösung:
Für Wan 2.2 würde ich bei dir zuerst den offiziellen nativen ComfyUI-Wan2.2-Workflow nutzen, nicht den WanVideoWrapper. In ComfyUI:

Workflow → Browse Templates → Video → Wan2.2 5B video generation

ComfyUI empfiehlt genau diesen nativen 5B-Workflow und schreibt, dass Wan2.2 5B mit nativer Offloading-Funktion sogar gut auf 8 GB VRAM passen soll. ([docs.comfy.org][1])

---

## 2. Zweiter Fehler: OOM beim VAE-Decoding, nicht beim Sampling

Wichtig: Das Sampling selbst hat funktioniert:

25 frames at 416x736 with 8 steps
8/8 [00:18, 2.34s/it]
[Sampling] Max allocated memory: 11.299 GB

Dann crasht es erst hier:

WanVAE decoding frames: 14%
Allocation on device 0 would exceed allowed memory
Currently allocated: 14.61 GiB
Requested: 455.27 MiB
Device limit: 15.61 GiB
Free: 9.19 MiB

Das heisst: Wan 2.2 5B passt beim Sampling gerade noch, aber beim VAE-Decoding fehlt dir rund ein halbes GB bis ein GB VRAM.

Du bist also nicht meilenweit daneben, sondern knapp am Limit.

---

## 3. Danach hast du es offenbar korrekt entschärft

Der spätere Run war erfolgreich:

25 frames at 416x736
8 steps
Sampling: 27s
VAE decoding: 26s
Prompt executed in 63.73 seconds

Und mit 12 Steps:

25 frames at 416x736
12 steps
Sampling: 01:10
VAE decoding: 25s
Prompt executed in 119.00 seconds

Das sieht so aus, als ob du zwischenzeitlich VAE-Tiling / anderes Decoding / stärkeres Offloading aktiviert hast. Dadurch läuft es durch, aber Decoding wird langsamer.

---

# Leistung im Vergleich zu Wan 2.1

Deine bisherigen Werte:

| Modell           |   Frames / Auflösung / Steps |    Gesamtzeit | Eindruck                |
| ---------------- | ---------------------------: | ------------: | ----------------------- |
| Wan 2.1 1.3B |  25 Frames, 416x736, 8 Steps |  ca. 47 s | schneller, stabiler     |
| Wan 2.2 5B   |  25 Frames, 416x736, 8 Steps |  ca. 64 s | langsamer, aber machbar |
| Wan 2.2 5B   | 25 Frames, 416x736, 12 Steps | ca. 119 s | deutlich langsamer      |

Das ist eigentlich ziemlich gut für deine RTX A5000 Laptop 16 GB.

Meine Einschätzung:
Wan 2.2 5B ist bei dir brauchbar, aber nicht so komfortabel wie Wan 2.1 1.3B. Es ist ein Modell für bessere finale Clips, nicht für massenhaft schnelle Iterationen.

---

# Was mich im Log irritiert

Diese Zeilen widersprechen sich etwas:

5B model detected
Model variant detected: 14B

Und:

Memory: 2,033,661.72 MB

Das ist offensichtlich keine reale VRAM-Angabe. Deine GPU hat 16 GB. Diese Anzeige ist vermutlich ein Wrapper-/Logging-Artefakt.

Für mich zählt hier mehr:

in_channels: 48
5B model detected
25 frames at 416x736

Das sieht sehr nach Wan2.2 TI2V 5B aus. Offiziell gibt es bei Wan2.2 ein 5B-Hybridmodell für Text-to-Video und Image-to-Video sowie separate 14B-Modelle für T2V/I2V. ([docs.comfy.org][1])

---

# Optimale Einstellung für deine GPU

## Für Wan 2.2 5B auf 16 GB VRAM

Ich würde so
starten:

Auflösung: 416x736
Frames: 25
Steps: 8
VAE tiling: ON
VAE decode batch/chunk: klein
EasyCache: ON, falls verfügbar
TeaCache/MagCache: nicht verwenden, wenn keine Koeffizienten verfügbar

Danach langsam erhöhen:

480x832
25 Frames
8 Steps

Erst wenn das stabil läuft:

480x832
33 Frames
8–10 Steps

Ich würde bei Wan 2.2 auf deiner GPU nicht direkt 49 oder 81 Frames machen.

---

# Konkrete Empfehlung

## Produktiver Workflow

Wan 2.1 1.3B
Für schnelle Varianten, Prompts, Kamerabewegung, Konzepttests.

416x736
25–33 Frames
6–8 Steps

Wan 2.2 5B
Für bessere finale Takes, wenn der Prompt schon sitzt.

416x736 oder 480x832
25–33 Frames
8 Steps
VAE tiling ON

Wan 2.2 14B
Auf deiner 16-GB-Laptop-GPU nicht als Standard. Nur später mit Low-VRAM-/GGUF-/FP8-Workflow, wenn du Geduld hast.

---

# Wichtigste Korrektur jetzt

Nutze für Wan 2.2 am besten den nativen ComfyUI-Wan2.2-Workflow:

Workflow → Browse Templates → Video → Wan2.2 5B video generation

Und prüfe, dass diese Dateien richtig liegen:

ComfyUI/models/diffusion_models/wan2.2_ti2v_5B_fp16.safetensors
ComfyUI/models/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors
ComfyUI/models/vae/wan2.2_vae.safetensors

Diese Pfade entsprechen der offiziellen ComfyUI-Wan2.2-Doku. ([docs.comfy.org][1])

---

## Mein Urteil

Wan 2.2 macht wahrscheinlich bessere Videos als Wan 2.1, aber auf deiner GPU ist es langsamer und VRAM-kritischer.

Für dich ist der beste Mix:

Wan 2.1 1.3B = schnelle Produktionsmaschine
Wan 2.2 5B = Qualitäts-Renderer für ausgewählte Clips
Wan 2.2 14B = vorerst nicht sinnvoll als Standard

Deine aktuelle Wan-2.2-Leistung mit 64 Sekunden für 25 Frames bei 416x736 ist brauchbar. Der 12-Step-Run mit 119 Sekunden ist für Qualitätstests okay, aber für Massenproduktion zu langsam.

[1]: https://docs.comfy.org/tutorials/video/wan/wan2_2 "Wan2.2 Video Generation ComfyUI Official Native Workflow Example - ComfyUI"    / geschwindigkeit für das erstellen der Videos ist für mich nicht so relevant, die Qualität hat vorrang. was müssen wir betreffend dem T5 encoder machen? wie ist das mit Ram-offload (auslagern in den Arbeitsspeicher wenn er mal mehr Vram braucht, geht das?) nicht dass er sich aufhängt...


Explanation:
**Evaluating tool options**

I need to determine the best way to answer by possibly utilizing tools or web resources. Since the user is asking about configuration, I might need to inspect native node availability or refer to current documentation. There's a suggestion to use the browser for documentation, so I’ll look into that. It’s essential to provide an accurate, well-informed response while making sure I understand the best approach for the user’s needs!


Wan2.2 Video Generation ComfyUI Official Native Workflow Example - ComfyUI

Running WITHOUT residential proxies. Bot detection may be more aggressive. Consider upgrading Browserbase plan for proxy support.

- generic
  - generic
    - link "Skip to main content" [ref=e1]
    - generic
      - generic
        - generic
          - link "ComfyUI home page light logo" [ref=e27]
            - StaticText "ComfyUI"
            - StaticText " home page"
            - image "light logo"
          - generic
            - link "Get Started" [ref=e74]
            - link "Built-in Nodes" [ref=e75]
            - link "Development" [ref=e76]
            - link "Support" [ref=e77]
            - link "Registry API Reference" [ref=e78]
            - link "Cloud API Reference" [ref=e79]
            - navigation
              - list
                - listitem [level=1]
                  - link "Download" [ref=e208]
                - listitem [level=1]
                  - link "Comfy Cloud" [ref=e209]
                    - StaticText "Comfy Cloud"
      - generic
        - generic
          - button "Open search" [ref=e28]
            - image
            - StaticText "Search..."
            - StaticText "Ctrl "
            - StaticText "K"
          - generic
            - list
            - heading "Get Started" [level=5, ref=e29]
            - list
              - listitem [level=1]
                - link "Introduction" [ref=e113]
                  - StaticText "Introduction"
              - listitem [level=1]
                - button "Toggle Local (Self-Hosted) section" [expanded=false, ref=e114]
                  - StaticText "Local (Self-Hosted)"
              - listitem [level=1]
                - link "Comfy Cloud" [ref=e115]
                  - StaticText "Comfy Cloud"
              - listitem [level=1]
                - button "Toggle Install Custom Nodes section" [expanded=false, ref=e116]
                  - StaticText "Install Custom Nodes"
              - listitem [level=1]
                - link "First Generation" [ref=e117]
                  - StaticText "First Generation"
            - heading "Basic Concepts" [level=5, ref=e30]
            - list
              - listitem [level=1]
                - link "Workflow" [ref=e118]
                  - StaticText "Workflow"
              - listitem [level=1]
                - link "Nodes" [ref=e119]
                  - StaticText "Nodes"
              - listitem [level=1]
                - link "Custom Nodes" [ref=e120]
                  - StaticText "Custom Nodes"
              - listitem [level=1]
                - link "Properties" [ref=e121]
                  - StaticText "Properties"
              - listitem [level=1]
                - link "Links" [ref=e122]
                  - StaticText "Links"
              - listitem [level=1]
                - link "Models" [ref=e123]
                  - StaticText "Models"
              - listitem [level=1]
                - link "Dependencies" [ref=e124]
                  - StaticText "Dependencies"
            - heading "Interface Guide" [level=5, ref=e31]
            - list
              - listitem [level=1]
                - link "Interface Overview" [ref=e125]
                  - StaticText "Interface Overview"
              - listitem [level=1]
                - link "APP mode" [ref=e126]
                  - StaticText "APP mode"
              - listitem [level=1]
                - link "Nodes 2.0" [ref=e127]
                  - StaticText "Nodes 2.0"
              - listitem [level=1]
                - link "Mask Editor" [ref=e128]
                  - StaticText "Mask Editor"
              - listitem [level=1]
                - link "Workflow Templates" [ref=e129]
                  - StaticText "Workflow Templates"
              - listitem [level=1]
                - link "Subgraph" [ref=e130]
                  - StaticText "Subgraph"
              - listitem [level=1]
                - link "Partial Execution" [ref=e131]
                  - StaticText "Partial Execution"
              - listitem [level=1]
                - link "Node docs" [ref=e132]
                  - StaticText "Node docs"
              - listitem [level=1]
                - button "Toggle ComfyUI Settings section" [expanded=false, ref=e133]
                  - StaticText "ComfyUI Settings"
              - listitem [level=1]
                - button "Toggle Cloud Exclusive section" [expanded=false, ref=e134]
                  - StaticText "Cloud Exclusive"
            - heading "Tutorials" [level=5, ref=e32]
            - list
              - listitem [level=1]
                - button "Toggle Basic Examples section" [expanded=false, ref=e135]
                  - StaticText "Basic Examples"
              - listitem [level=1]
                - button "Toggle ControlNet section" [expanded=false, ref=e136]
                  - StaticText "ControlNet"
              - listitem [level=1]
                - button "Toggle Image section" [expanded=false, ref=e137]
                  - StaticText "Image"
              - listitem [level=1]
                - button "Toggle 3D section" [expanded=false, ref=e138]
                  - StaticText "3D"
              - listitem [level=1]
                - button "Toggle Video section" [expanded=true, ref=e139]
                  - StaticText "Video"
                - list
                  - listitem [level=2]
                    - button "Toggle LTX section" [expanded=false, ref=e210]
                      - StaticText "LTX"
                  - listitem [level=2]
                    - button "Toggle Wan Video section" [expanded=true, ref=e211]
                      - StaticText "Wan Video"
                    - list
                      - listitem [level=3]
                        - link "Wan2.2" [ref=e248]
                      - listitem [level=3]
                        - link "Wan2.2 Animate" [ref=e249]
                      - listitem [level=3]
                        - link "Wan2.2 S2V" [ref=e250]
                      - listitem [level=3]
                        - link "Wan2.2 Fun Inp" [ref=e251]
                      - listitem [level=3]
                        - link "Wan2.2 Fun Control" [ref=e252]
                      - listitem [level=3]
                        - link "Wan2.2 Fun Camera" [ref=e253]
                      - listitem [level=3]
                        - button "Toggle Wan2.1 section" [expanded=false, ref=e254]
                  - listitem [level=2]
                    - button "Toggle Hunyuan section" [expanded=false, ref=e212]
                  - listitem [level=2]
                    - button "Toggle Cosmos section" [expanded=false, ref=e213]
                  - listitem [level=2]
                    - button "Toggle Kandinsky section" [expanded=false, ref=e214]
              - listitem [level=1]
                - button "Toggle Audio section" [expanded=false, ref=e140]
                  - StaticText "Audio"
              - listitem [level=1]
                - button "Toggle Utility section" [expanded=false, ref=e141]
                  - StaticText "Utility"
              - listitem [level=1]
                - button "Toggle Partner Nodes section" [expanded=false, ref=e142]
                  - StaticText "Partner Nodes"
            - list
              - listitem [level=1]
                - link "Changelog" [ref=e143]
                  - StaticText "Changelog"
          - button "English" [expanded=false, ref=e2]
            - StaticText "English"
          - button "Toggle dark mode" [ref=e3]
            - image
            - image
        - generic
          - navigation "On this page" [ref=e80]
            - heading "On this page" [level=2, ref=e144]
              - button "On this page" [ref=e200]
                - StaticText "On this page"
            - list
              - listitem [level=1]
                - link "Model Highlights" [ref=e215]
              - listitem [level=1]
                - link "Wan2.2 Open Source Model Versions" [ref=e216]
              - listitem [level=1]
                - link "ComfyOrg Wan2.2 Live Streams" [ref=e217]

[... 613 more lines truncated, use browser_snapshot for full content]


- generic
  - generic
    - link "Skip to main content" [ref=e1]
    - generic
      - generic
        - generic
          - link "ComfyUI home page light logo" [ref=e27]
            - StaticText "ComfyUI"
            - StaticText " home page"
            - image "light logo"
          - generic
            - link "Get Started" [ref=e74]
            - link "Built-in Nodes" [ref=e75]
            - link "Development" [ref=e76]
            - link "Support" [ref=e77]
            - link "Registry API Reference" [ref=e78]
            - link "Cloud API Reference" [ref=e79]
            - navigation
              - list
                - listitem [level=1]
                  - link "Download" [ref=e217]
                - listitem [level=1]
                  - link "Comfy Cloud" [ref=e218]
                    - StaticText "Comfy Cloud"
      - generic
        - generic
          - button "Open search" [ref=e28]
            - image
            - StaticText "Search..."
            - StaticText "Ctrl "
            - StaticText "K"
          - generic
            - list
            - heading "Get Started" [level=5, ref=e29]
            - list
              - listitem [level=1]
                - link "Introduction" [ref=e122]
                  - StaticText "Introduction"
              - listitem [level=1]
                - button "Toggle Local (Self-Hosted) section" [expanded=false, ref=e123]
                  - StaticText "Local (Self-Hosted)"
              - listitem [level=1]
                - link "Comfy Cloud" [ref=e124]
                  - StaticText "Comfy Cloud"
              - listitem [level=1]
                - button "Toggle Install Custom Nodes section" [expanded=false, ref=e125]
                  - StaticText "Install Custom Nodes"
              - listitem [level=1]
                - link "First Generation" [ref=e126]
                  - StaticText "First Generation"
            - heading "Basic Concepts" [level=5, ref=e30]
            - list
              - listitem [level=1]
                - link "Workflow" [ref=e127]
                  - StaticText "Workflow"
              - listitem [level=1]
                - link "Nodes" [ref=e128]
                  - StaticText "Nodes"
              - listitem [level=1]
                - link "Custom Nodes" [ref=e129]
                  - StaticText "Custom Nodes"
              - listitem [level=1]
                - link "Properties" [ref=e130]
                  - StaticText "Properties"
              - listitem [level=1]
                - link "Links" [ref=e131]
                  - StaticText "Links"
              - listitem [level=1]
                - link "Models" [ref=e132]
                  - StaticText "Models"
              - listitem [level=1]
                - link "Dependencies" [ref=e133]
                  - StaticText "Dependencies"
            - heading "Interface Guide" [level=5, ref=e31]
            - list
              - listitem [level=1]
                - link "Interface Overview" [ref=e134]
                  - StaticText "Interface Overview"
              - listitem [level=1]
                - link "APP mode" [ref=e135]
                  - StaticText "APP mode"
              - listitem [level=1]
                - link "Nodes 2.0" [ref=e136]
                  - StaticText "Nodes 2.0"
              - listitem [level=1]
                - link "Mask Editor" [ref=e137]
                  - StaticText "Mask Editor"
              - listitem [level=1]
                - link "Workflow Templates" [ref=e138]
                  - StaticText "Workflow Templates"
              - listitem [level=1]
                - link "Subgraph" [ref=e139]
                  - StaticText "Subgraph"
              - listitem [level=1]
                - link "Partial Execution" [ref=e140]
                  - StaticText "Partial Execution"
              - listitem [level=1]
                - link "Node docs" [ref=e141]
                  - StaticText "Node docs"
              - listitem [level=1]
                - button "Toggle ComfyUI Settings section" [expanded=false, ref=e142]
                  - StaticText "ComfyUI Settings"
              - listitem [level=1]
                - button "Toggle Cloud Exclusive section" [expanded=false, ref=e143]
                  - StaticText "Cloud Exclusive"
            - heading "Tutorials" [level=5, ref=e32]
            - list
              - listitem [level=1]
                - button "Toggle Basic Examples section" [expanded=false, ref=e144]
                  - StaticText "Basic Examples"
              - listitem [level=1]
                - button "Toggle ControlNet section" [expanded=false, ref=e145]
                  - StaticText "ControlNet"
              - listitem [level=1]
                - button "Toggle Image section" [expanded=false, ref=e146]
                  - StaticText "Image"
              - listitem [level=1]
                - button "Toggle 3D section" [expanded=false, ref=e147]
                  - StaticText "3D"
              - listitem [level=1]
                - button "Toggle Video section" [expanded=true, ref=e148]
                  - StaticText "Video"
                - list
                  - listitem [level=2]
                    - button "Toggle LTX section" [expanded=false, ref=e219]
                      - StaticText "LTX"
                  - listitem [level=2]
                    - button "Toggle Wan Video section" [expanded=true, ref=e220]
                      - StaticText "Wan Video"
                    - list
                      - listitem [level=3]
                        - link "Wan2.2" [ref=e257]
                          - StaticText "Wan2.2"
                      - listitem [level=3]
                        - link "Wan2.2 Animate" [ref=e258]
                          - StaticText "Wan2.2 Animate"
                      - listitem [level=3]
                        - link "Wan2.2 S2V" [ref=e259]
                          - StaticText "Wan2.2 S2V"
                      - listitem [level=3]
                        - link "Wan2.2 Fun Inp" [ref=e260]
                          - StaticText "Wan2.2 Fun Inp"
                      - listitem [level=3]
                        - link "Wan2.2 Fun Control" [ref=e261]
                          - StaticText "Wan2.2 Fun Control"
                      - listitem [level=3]
                        - link "Wan2.2 Fun Camera" [ref=e262]
                          - StaticText "Wan2.2 Fun Camera"
                      - listitem [level=3]
                        - button "Toggle Wan2.1 section" [expanded=false, ref=e263]
                          - StaticText "Wan2.1"
                  - listitem [level=2]
                    - button "Toggle Hunyuan section" [expanded=false, ref=e221]
                      - StaticText "Hunyuan"
                  - listitem [level=2]
                    - button "Toggle Cosmos section" [expanded=false, ref=e222]
                      - StaticText "Cosmos"
                  - listitem [level=2]
                    - button "Toggle Kandinsky section" [expanded=false, ref=e223]
                      - StaticText "Kandinsky"
              - listitem [level=1]
                - button "Toggle Audio section" [expanded=false, ref=e149]
                  - StaticText "Audio"
              - listitem [level=1]
                - button "Toggle Utility section" [expanded=false, ref=e150]
                  - StaticText "Utility"
              - listitem [level=1]
                - button "Toggle Partner Nodes section" [expanded=false, ref=e151]
                  - StaticText "Partner Nodes"
            - list
              - listitem [level=1]
                - link "Changelog" [ref=e152]
                  - StaticText "Changelog"
          - button "English" [expanded=false, ref=e2]
            - StaticText "English"
          - button "Toggle dark mode" [ref=e3]
            - image
            - image

[... 839 more lines truncated, use browser_snapshot for full content]


Explanation:
**Considering text extraction**

I think I need to extract visible text using the browser console. It's an interesting approach, and I'm curious about how to go about it. I wonder if I should look up some specific commands or scripts that can help with that. It feels like there could be various methods, but having a clear goal in mind will guide me. I'll do a little bit of digging to ensure I’m on the right track!

document.body.innerText.match(/Model Download[\s\S]{0,3000}/)?.[0] || document.body.innerText.slice(document.body.innerText.indexOf('Model Download'), document.body.innerText.indexOf('Workflow Example'))


document.body.innerText.includes('umt5') ? document.body.innerText.match(/umt5[\s\S]{0,1000}/)[0] : document.body.innerText.slice(0,5000)


umt5_xxl_fp8_e4m3fn_scaled.safetensors
ComfyUI/
├───📂 models/
│   ├───📂 diffusion_models/
│   │   └───wan2.2_ti2v_5B_fp16.safetensors
│   ├───📂 text_encoders/
│   │   └─── umt5_xxl_fp8_e4m3fn_scaled.safetensors
│   └───📂 vae/
│       └── wan2.2_vae.safetensors

3. Follow the Steps
Ensure the Load Diffusion Model node loads the wan2.2_ti2v_5B_fp16.safetensors model.
Ensure the Load CLIP node loads the umt5_xxl_fp8_e4m3fn_scaled.safetensors model.
Ensure the Load VAE node loads the wan2.2_vae.safetensors model.
(Optional) If you need to perform image-to-video generation, you can use the shortcut Ctrl+B to enable the Load image node to upload an image.
(Optional) In the Wan22ImageToVideoLatent node, you can adjust the size settings and the total number of video frames (length).
(Optional) If you need to modify the prompts (positive and negative), please do so in the CLIP Text Encoder node at step 5.
Click the Run button, or use the shortcut Ctrl(cmd) + Enter to execute video generation


wan2.2_ti2v_5B_fp16.safetensors
VAE
wan2.2_vae.safetensors
Text Encoder
umt5_xxl_fp8_e4m3fn_scaled.safetensors
ComfyUI/
├───📂 models/
│   ├───📂 diffusion_models/
│   │   └───wan2.2_ti2v_5B_fp16.safetensors
│   ├───📂 text_encoders/
│   │   └─── umt5_xxl_fp8_e4m3fn_scaled.safetensors
│   └───📂 vae/
│       └── wan2.2_vae.safetensors

3. Follow the Steps
Ensure the Load Diffusion Model node loads the wan2.2_ti2v_5B_fp16.safetensors model.
Ensure the Load CLIP node loads the umt5_xxl_fp8_e4m3fn_scaled.safetensors model.
Ensure the Load VAE node loads the wan2.2_vae.safetensors model.
(Optional) If you need to perform image-to-video generation, you can use the shortcut Ctrl+B to enable the Load image node to upload an image.
(Optional) In the Wan22ImageToVideoLatent node, you can adjust the size settings and the total number of video frames (length).
(Optional) If you need to modify the prompts (positive and negative), please do so in the CLIP Text Encoder node at step 5.
Click the Run button, or use the shortcut Ctrl(cmd) + Enter to execute video generation.

Wan2.2 14B T2V Text-to-Video Workflow Example

1. Workflow File
Please update your ComfyUI to the latest version, and through the menu Workflow -> Browse Templates -> Video, find “Wan2.2 14B T2V” to load the workflow.
Or update your ComfyUI to the latest version, then download the following video and drag it into ComfyUI to load the workflow.

Download JSON Workflow File

Run on Comfy Cloud

2. Manually Download Models
Diffu


Explanation:
**Clarifying workflow requirements**

I need to finalize the native workflow and figure out the necessary commands for model download. I'll look into RAM offload, as Comfy's dynamic VRAM offloads components to CPU RAM when under pressure. It's important to ensure that there's enough system RAM; otherwise, things could hang. I should consider recommending ComfyUI's native option instead of a wrapper. The user asked what to do, so I might provide step-by-step commands. Additionally, I should suggest increasing swap space to 32GB for safety.
**Looking into swapfile commands**

I need to find the right commands for setting up a zram or swapfile. I think offering an optional 32GB swapfile is a good idea, but I have to be cautious about disk space. It might be helpful to use some tools to inspect if native nodes already exist. Also, I need to gather terminal object information for the native Wan nodes, like Wan22ImageToVideoLatent, to ensure everything is set up correctly.

python - <<'PY'
import json, urllib.request
obj=json.load(urllib.request.urlopen('http://100.101.173.25:8188/object_info', timeout=20))
for k in sorted(obj):
    if any(s in k.lower() for s in ['wan22','wan2.2','wan22imagetovideolatent','wan22text']):
        print(k, obj[k].get('display_name'))
PY


Output:
Wan22FunControlToVideo None
Wan22ImageToVideoLatent None