diff --git a/conditioning_loader.py b/conditioning_loader.py
index 40d9be9..f513ce4 100644
--- a/conditioning_loader.py
+++ b/conditioning_loader.py
@@ -1,4 +1,5 @@
 import hashlib
+import json
 from pathlib import Path
 from typing import Any
 
@@ -47,15 +48,39 @@ class LTXVLoadConditioning(io.ComfyNode):
         ) as f:
             tensor_keys = [k for k in f.keys() if k.startswith("conditioning_data_")]
 
+            all_keys = list(f.keys())
+            file_metadata = f.metadata() or {}
+            try:
+                non_tensor_options = json.loads(
+                    file_metadata.get("non_tensor_options", "{}")
+                )
+            except (TypeError, ValueError):
+                non_tensor_options = {}
+
             for tensor_key in sorted(tensor_keys):
                 idx = tensor_key.replace("conditioning_data_", "")
                 tensor = f.get_tensor(tensor_key)
 
                 options: dict[str, Any] = {}
+
+                # Files written before the opt_ prefix existed store the mask
+                # under its bare name. Read it first so a newer opt_ entry wins.
                 mask_key = f"attention_mask_{idx}"
-                if mask_key in f.keys():
+                if mask_key in all_keys:
                     options["attention_mask"] = f.get_tensor(mask_key)
 
+                opt_prefix = "opt_"
+                opt_suffix = f"_{idx}"
+                for key in all_keys:
+                    if key.startswith(opt_prefix) and key.endswith(opt_suffix):
+                        opt_name = key[len(opt_prefix):-len(opt_suffix)]
+                        options[opt_name] = f.get_tensor(key)
+
+                for meta_key, meta_value in non_tensor_options.items():
+                    meta_idx, _, opt_name = meta_key.partition(":")
+                    if meta_idx == idx:
+                        options[opt_name] = meta_value
+
                 conditioning.append([tensor, options])
 
         if not conditioning:
diff --git a/conditioning_saver.py b/conditioning_saver.py
index 9a7bb8a..06cd886 100644
--- a/conditioning_saver.py
+++ b/conditioning_saver.py
@@ -1,3 +1,4 @@
+import json
 from datetime import datetime
 from pathlib import Path
 
@@ -44,19 +45,30 @@ class LTXVSaveConditioning(io.ComfyNode):
         target_dtype = torch.bfloat16 if dtype == "bfloat16" else torch.float16
 
         tensors_to_save: dict[str, torch.Tensor] = {}
+        # Non-tensor options (e.g. the unprocessed_ltxav_embeds flag) are just as
+        # load-bearing as the embeddings themselves - without them the model can
+        # silently mis-handle the conditioning - so round-trip them via metadata.
+        non_tensor_options: dict[str, object] = {}
 
         for idx, (cond_tensor, cond_options) in enumerate(conditioning):
             tensor_converted = cond_tensor.to(dtype=target_dtype).contiguous()
             tensors_to_save[f"conditioning_data_{idx}"] = tensor_converted
 
-            if "attention_mask" in cond_options:
-                mask = cond_options["attention_mask"].contiguous()
-                tensors_to_save[f"attention_mask_{idx}"] = mask
+            for key, value in cond_options.items():
+                if torch.is_tensor(value):
+                    tensors_to_save[f"opt_{key}_{idx}"] = value.contiguous()
+                else:
+                    try:
+                        json.dumps(value)
+                    except (TypeError, ValueError):
+                        continue
+                    non_tensor_options[f"{idx}:{key}"] = value
 
         metadata = {
             "num_conditionings": str(len(conditioning)),
             "dtype": dtype,
             "created_at": str(datetime.now()),
+            "non_tensor_options": json.dumps(non_tensor_options),
         }
 
         comfy.utils.save_torch_file(