pull · Sep 20, 2026 · Sep 19, 2026 · Sep 19, 2026 · Sep 20, 2026
diff --git a/comfy/latent_formats.py b/comfy/latent_formats.py
@@ -928,6 +928,59 @@ class HunyuanImage21(LatentFormat):
 
     latent_rgb_factors_bias = [0.0007, -0.0256, -0.0206]
 
+class QwenImage21(LatentFormat):
+    latent_channels = 64
+    latent_dimensions = 2
+    spacial_downscale_ratio = 16
+
+    latent_rgb_factors = [
+        [-0.0158, -0.0115, -0.0174], [ 0.0030,  0.0120,  0.0027], [ 0.0637,  0.0470, -0.0127], [ 0.0360,  0.0661, -0.0030],
+        [ 0.0159,  0.0181,  0.0082], [ 0.0132,  0.0326,  0.0169], [ 0.0191,  0.0261,  0.0136], [-0.0146, -0.0276, -0.0361],
+        [ 0.0187, -0.0024, -0.0072], [-0.1059, -0.0090,  0.0350], [-0.0195, -0.0226, -0.0138], [-0.0295,  0.0024, -0.0215],
+        [ 0.0191, -0.0393, -0.0001], [-0.0144, -0.0166, -0.0272], [ 0.0389,  0.0430,  0.0445], [-0.0153, -0.0336,  0.0031],
+        [ 0.0339,  0.0122,  0.0220], [-0.0136, -0.0078, -0.0120], [-0.0340, -0.0282, -0.0245], [-0.0133, -0.0176, -0.0133],
+        [ 0.0109, -0.0087,  0.0096], [-0.0010,  0.0044,  0.0016], [ 0.0301,  0.0053,  0.0361], [-0.0281, -0.0205, -0.0032],
+        [-0.0725,  0.0002,  0.0160], [-0.0036,  0.0158,  0.0807], [ 0.0087,  0.0040, -0.0053], [-0.0260,  0.0183, -0.0077],
+        [-0.0039, -0.0035, -0.0107], [-0.0026,  0.0172,  0.0237], [ 0.0088,  0.0078,  0.0078], [-0.0087, -0.0310, -0.0122],
+        [-0.0027,  0.0018,  0.0094], [-0.0064,  0.0292, -0.0256], [ 0.0594,  0.1049,  0.1180], [ 0.0103, -0.0103, -0.0026],
+        [-0.0091,  0.0025, -0.0015], [ 0.0178,  0.0243,  0.0292], [-0.0063, -0.0012,  0.0202], [ 0.0452,  0.0246,  0.0143],
+        [ 0.0149,  0.0270,  0.0052], [ 0.1484,  0.0801,  0.0804], [-0.0120,  0.0040,  0.0010], [ 0.0181,  0.0051, -0.0021],
+        [ 0.0132,  0.0050,  0.0019], [ 0.0291,  0.0020,  0.0092], [ 0.0066, -0.0410, -0.1314], [-0.1153, -0.0629, -0.0802],
+        [ 0.0258,  0.0378,  0.0298], [ 0.0375,  0.1139,  0.0468], [-0.0142, -0.0126, -0.0276], [ 0.0339,  0.0153,  0.0138],
+        [ 0.0346,  0.0211,  0.0267], [ 0.0369, -0.0431, -0.0993], [-0.0052, -0.0092,  0.0056], [-0.0279,  0.0410, -0.0357],
+        [ 0.0036,  0.0017, -0.0083], [-0.0441, -0.0367, -0.0454], [-0.0001, -0.0092, -0.0001], [-0.0222, -0.0183, -0.0051],
+        [ 0.0039,  0.0053, -0.0184], [-0.0094, -0.0075, -0.0143], [-0.0066, -0.0088, -0.0063], [ 0.0220,  0.0074,  0.0100],
+    ]
+    latent_rgb_factors_bias = [-0.1228, -0.1869, -0.3083]
+
+    def __init__(self):
+        self.latents_mean = torch.tensor([
+            0.5126, 0.7721, -0.0631, 1.3506, -0.7855, -2.1025, -0.3458, 1.3722,
+            1.8873, -1.7177, -0.6510, 0.2732, 0.7562, -0.6163, -1.0277, 3.8363,
+            2.0210, 0.0472, 0.9320, 2.0087, 2.4954, -0.1391, -1.4249, 1.8464,
+            -0.5236, 1.2826, 3.7046, -1.3035, 2.7286, -1.4518, -1.9036, -1.9955,
+            -0.0342, -1.0265, -0.7636, 3.0555, 0.0746, -3.0751, -0.1076, 1.7376,
+            -1.0914, -1.9435, -0.2784, -1.3680, 0.4809, -0.4433, 0.3764, 0.5729,
+            -2.0595, 1.0960, -1.3260, -2.0211, -5.0179, 0.5275, 4.0162, 1.8505,
+            0.3026, 1.9373, 1.4937, 0.2632, 0.5547, -1.7121, -0.1562, 0.0304,
+        ]).view(1, self.latent_channels, 1, 1)
+        self.latents_std = torch.tensor([
+            3.2001, 3.2936, 3.4321, 3.0091, 3.1061, 4.0379, 4.0705, 3.7910,
+            3.0785, 3.6500, 3.9308, 3.0904, 2.8778, 3.7675, 3.7320, 5.0756,
+            3.2864, 4.0397, 3.1317, 4.0443, 2.9249, 3.9454, 3.0988, 4.2489,
+            3.4896, 3.8513, 3.9323, 3.4719, 3.7498, 4.2830, 3.5694, 4.2467,
+            3.9037, 3.2947, 5.0770, 3.5075, 3.2700, 3.4767, 2.8063, 5.1125,
+            3.5327, 4.7833, 3.1286, 4.1819, 3.8527, 3.8312, 3.5605, 4.3875,
+            3.9624, 4.0168, 3.5643, 4.0550, 5.5614, 4.2963, 4.4080, 3.4959,
+            3.8747, 3.7608, 3.5735, 3.1490, 3.7662, 3.6746, 3.4563, 3.8161,
+        ]).view(1, self.latent_channels, 1, 1)
+
+    def process_in(self, latent):
+        return (latent - self.latents_mean.to(latent.device, latent.dtype)) / self.latents_std.to(latent.device, latent.dtype)
+
+    def process_out(self, latent):
+        return latent * self.latents_std.to(latent.device, latent.dtype) + self.latents_mean.to(latent.device, latent.dtype)
+
 class HunyuanImage21Refiner(LatentFormat):
     latent_channels = 64
     latent_dimensions = 3

diff --git a/comfy/ldm/qwen_image21/model.py b/comfy/ldm/qwen_image21/model.py
diff --git a/comfy/ldm/wan/model.py b/comfy/ldm/wan/model.py
@@ -6,7 +6,7 @@
 import torch.nn as nn
 from einops import rearrange
 
-from comfy.ldm.modules.attention import optimized_attention
+from comfy.ldm.modules.attention import AttentionTensorContainer, optimized_attention
 from comfy.ldm.flux.layers import EmbedND
 from comfy.ldm.flux.math import apply_rope1, rope
 import comfy.ldm.common_dit
@@ -81,17 +81,21 @@ def qkv_fn_k(x):
         q = qkv_fn_q(x)
         k = qkv_fn_k(x)
 
+        if patches.get("attn1_patch"):
+            q_patch, k_patch = q, k
+        q = AttentionTensorContainer(q.view(b, s, n * d))
+        k = AttentionTensorContainer(k.view(b, s, n * d))
+        v = AttentionTensorContainer(self.v(x).view(b, s, n * d))
+
         x = optimized_attention(
-            q.view(b, s, n * d),
-            k.view(b, s, n * d),
-            self.v(x).view(b, s, n * d),
+            q, k, v,
             heads=self.num_heads,
             transformer_options=transformer_options,
         )
 
         if "attn1_patch" in patches:
             for p in patches["attn1_patch"]:
-                x = p({"x": x, "q": q, "k": k, "transformer_options": transformer_options})
+                x = p({"x": x, "q": q_patch, "k": k_patch, "transformer_options": transformer_options})
 
         x = self.o(x)
         return x
@@ -106,9 +110,9 @@ def forward(self, x, context, transformer_options={}, **kwargs):
             context(Tensor): Shape [B, L2, C]
         """
         # compute query, key, value
-        q = self.norm_q(self.q(x))
-        k = self.norm_k(self.k(context))
-        v = self.v(context)
+        q = AttentionTensorContainer(self.norm_q(self.q(x)))
+        k = AttentionTensorContainer(self.norm_k(self.k(context)))
+        v = AttentionTensorContainer(self.v(context))
 
         # compute attention
         x = optimized_attention(q, k, v, heads=self.num_heads, transformer_options=transformer_options)
@@ -143,13 +147,15 @@ def forward(self, x, context, context_img_len, transformer_options={}):
 
         # compute query, key, value
         q = self.norm_q(self.q(x))
-        k = self.norm_k(self.k(context))
-        v = self.v(context)
         k_img = self.norm_k_img(self.k_img(context_img))
         v_img = self.v_img(context_img)
         # Sageattn can cause Nans here, don't allow it as there is no speed difference anyway as img attention is tiny.
         img_x = optimized_attention(q, k_img, v_img, heads=self.num_heads, transformer_options=transformer_options, low_precision_attention=False)
+        del k_img, v_img
         # compute attention
+        q = AttentionTensorContainer(q)
+        k = AttentionTensorContainer(self.norm_k(self.k(context)))
+        v = AttentionTensorContainer(self.v(context))
         x = optimized_attention(q, k, v, heads=self.num_heads, transformer_options=transformer_options)
 
         # output

diff --git a/comfy/ldm/wan/model_animate2.py b/comfy/ldm/wan/model_animate2.py
@@ -116,7 +116,8 @@ class PoseBranchCache:
     Caching the block input rather than its K/V halves the memory; reprojecting K/V on read
     costs ~4% of re-running the block. One slot per distinct pose sequence, so under
     context windows each window keeps its own; least recently used slots are evicted when
-    the store device runs low on memory. Created and freed by WanAnimate2Cache.
+    the store device runs low on memory. Created and freed by WanAnimate2Cache; Qwen-Image 2.1
+    also stores its prefix K/V in it.
     """
 
     CONVROT_GROUPSIZE = 256
@@ -129,21 +130,22 @@ def __init__(self, store_device=None, dtype="default"):
         self._pending = {}
         self._staging = {}
 
-    def select(self, pose_latents):
+    def select(self, k, create=True):
         # select runs at a forward boundary: an interrupted forward can leave copies in flight that a different slot's forward would then mistake for its own
         if self._pending:
             for t, stream in self._pending.values():
                 if stream is not None:
                     stream.synchronize()
             self._pending = {}
-        # keyed on batch element 0, so a cond batch size change mid-run stays valid
-        k = pose_latents[:1]
         for s in self.slots:
             if s["key"].shape == k.shape and torch.equal(s["key"], k.to(s["key"].device)):
                 self.slots.remove(s)
                 self.slots.append(s)
                 self.slot = s
-                return
+                return True
+        self.slot = None
+        if not create:
+            return False
         # cache what fits: a filled slot is the size estimate for the next one, and least recently used slots make room when the store device runs low
         est = max((self._slot_bytes(s) for s in self.slots), default=0) * 1.5
         while self.slots and comfy.model_management.get_free_memory(self.store_device) < est:
@@ -169,8 +171,7 @@ def free(self):
     def filled(self, num_blocks):
         return self.slot is not None and len(self.slot["blocks"]) == num_blocks
 
-    def put(self, i, x_pose):
-        t = x_pose[:1]
+    def put(self, i, t):
         params = None
         if self.dtype in ("int8", "int4"):
             # convrot is what lets low-bit survive the ~125x per-channel outliers here, and over a [tokens, dim] view per-row scale means per-token. The kernels want 2D and a power-of-4 group that divides dim.
@@ -294,7 +295,7 @@ def forward_orig(self, x, t, context, clip_fea=None, freqs=None, freqs_pose=None
 
         cache = transformer_options.get("animate2_cache", None) if apply_pose else None
         if cache is not None:
-            cache.select(pose_latents)
+            cache.select(pose_latents[:1])  # keyed on batch element 0, so a cond batch size change mid-run stays valid
         cached = cache is not None and cache.filled(len(self.blocks))
 
         x_pose = None
@@ -342,7 +343,7 @@ def forward_orig(self, x, t, context, clip_fea=None, freqs=None, freqs_pose=None
             # pose-only prepass, to avoid inflating dynamic VRAM calibration when using multiple context windows
             for i, block in enumerate(self.blocks):
                 transformer_options["block_index"] = i
-                cache.put(i, x_pose)
+                cache.put(i, x_pose[:1])
                 x_pose = block.forward_pose(x_pose, e0_pose, freqs_pose, context_pose, context_img_len=context_img_len_pose, transformer_options=transformer_options)[0]
             x_pose = None
             cached = True
@@ -365,7 +366,7 @@ def forward_orig(self, x, t, context, clip_fea=None, freqs=None, freqs_pose=None
                 del x_pose_in
             else:
                 if cache is not None:
-                    cache.put(i, x_pose)
+                    cache.put(i, x_pose[:1])
                 # runs even under a block replace: its state has to reach block i+1
                 x_pose, k_pose, v_pose = block.forward_pose(x_pose, e0_pose, freqs_pose, context_pose, context_img_len=context_img_len_pose, transformer_options=transformer_options)
             if v_pose is not None and pose_strength != 1.0: