diff --git a/.gitmodules b/.gitmodules
index 9189d57..2b594d1 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,6 @@
 [submodule "third_party/ggml"]
 	path = third_party/ggml
-	url = https://github.com/yiming-l21/ggml.git
+	url = https://github.com/Komorebi623/ggml.git
 	branch = edge-cudnn-sdpa
 [submodule "third_party/onednn"]
 	path = third_party/onednn
diff --git a/README.md b/README.md
index 694e4df..9527d9c 100644
--- a/README.md
+++ b/README.md
@@ -39,7 +39,7 @@ placement, and backend selection.
   - Shared **C API, CLI, HTTP server, and Python** interfaces across every family
 
 - **Fits large models into limited VRAM**
-  - **`--auto-fit`** — one flag auto-picks DiT **quantization** (`q8_0`→`q4_K`) *and* per-component placement to meet a hard VRAM budget
+  - **`--auto-fit`** — one flag auto-picks DiT **quantization** (`q8_0`→`q4_K`) and per-component placement; on single-device CUDA, pairing it with `--max-vram` also enforces an allocation ceiling
   - **Layered offload** — streams the diffusion transformer **one block at a time** (async double-buffered on CUDA), so 20 GB+ models run on a 24 GB or smaller card
   - **Per-component offload** (`--dit-offload` / `--text-encoder-offload` / `--vae-offload`) and **VAE tiling**
   - **`ed-convert`** — offline weight quantization to a **portable pre-quantized GGUF** (skips per-load CPU quantization), with per-tensor dtype rules and activation-calibrated **imatrix**
@@ -57,7 +57,7 @@ placement, and backend selection.
 - **2026-08-14:** 🚀 Added **MiniMax-H3 FL2VA and Ref2VA video+audio generation** with image, video, embedded/paired audio, and mixed references; full or pruned BF16 DiTs, persistent Q8_0 conversion, Q4_K_M weights, and automatic VRAM fitting are supported ([usage and H200 results](docs/minimax-h3.md)).
 - **2026-08-05:** 🚀 Completed the **RTX 4090 (24 GB) benchmark** — full cross-system speed / VRAM / image-quality across text-to-image, editing, and video ([results](docs/performance-4090.md)).
 - **2026-07-30:** 🚀 Added **per-component offload** (`--dit-offload` / `--text-encoder-offload` / `--vae-offload`), unifying all offload paths on one semantics.
-- **2026-07-29:** 🚀 Added **`--auto-fit`** — one flag picks DiT quantization *and* per-component placement to fit a hard VRAM budget.
+- **2026-07-29:** 🚀 Added **`--auto-fit`** — one flag picks DiT quantization and per-component placement; `--auto-fit --max-vram <GB>` enforces the requested single-device CUDA allocation ceiling.
 - **2026-07-27:** 🚀 Added **few-step distilled** auto-detection (Turbo/Lightning/schnell → 4–8 steps) and optional **SageAttention** for SD3/Wan.
 - **2026-07-23:** 🚀 Added **`ed-convert`** for offline weight quantization to portable pre-quantized GGUF (with activation-calibrated `--imatrix`).
 - **2026-07-11:** 🚀 **edge-dit.cpp v0.1.0-alpha** enters **public preview**.
@@ -162,8 +162,8 @@ Generation latency is the primary cross-runtime performance metric.
 
 MiniMax-H3 has a separate 124-frame H200 benchmark because it generates video
 and audio rather than one image. In the current resident-component BF16
-comparison, Edge is faster than Diffusers in all four FL2VA and all four Ref2VA
-generation paths while using less peak VRAM. FL2VA text-to-video takes
+comparison, edge-dit.cpp is faster than Diffusers in all four FL2VA and all four
+Ref2VA generation paths while using less peak VRAM. FL2VA text-to-video takes
 `51.396s` versus `53.986s`; Ref2VA image and mixed-reference generation reach
 `1.08x` and `1.06x` speedups. Full and pruned BF16 DiTs are supported directly,
 and either can be converted once to persistent Q8_0 GGUF. `--auto-fit` has also
diff --git a/docs/assets/minimax-h3-ref2va-four-image-edge-comfyui-diffusers-demo.mp4 b/docs/assets/minimax-h3-ref2va-four-image-edge-comfyui-diffusers-demo.mp4
new file mode 100644
index 0000000..bde3bf4
Binary files /dev/null and b/docs/assets/minimax-h3-ref2va-four-image-edge-comfyui-diffusers-demo.mp4 differ
diff --git a/docs/assets/minimax-h3-ref2va-h200-15s-metrics.json b/docs/assets/minimax-h3-ref2va-h200-15s-metrics.json
new file mode 100644
index 0000000..875cac3
--- /dev/null
+++ b/docs/assets/minimax-h3-ref2va-h200-15s-metrics.json
@@ -0,0 +1,92 @@
+{
+  "date": "2026-08-16",
+  "device": "NVIDIA H200",
+  "sampling": {
+    "frames": 362,
+    "fps": 24,
+    "steps": 20,
+    "cfg": 1.0,
+    "seed": 157368968253448,
+    "sampler": "res_multistep",
+    "scheduler": "simple"
+  },
+  "tasks": {
+    "four_image_action": {
+      "width": 1280,
+      "height": 736,
+      "reference_images": 4,
+      "frameworks": {
+        "edge-dit.cpp": {
+          "end_to_end_seconds": 919.765,
+          "load_seconds": 17.773,
+          "conditioning_seconds": 2.641,
+          "dit_seconds": 839.890,
+          "video_vae_decode_seconds": 41.842,
+          "audio_vae_decode_seconds": 0.369,
+          "save_seconds": 5.519,
+          "peak_device_mib": 52667
+        },
+        "ComfyUI": {
+          "end_to_end_seconds": 1055.354,
+          "peak_device_mib": 49413,
+          "memory_sample_interval_seconds": 0.2,
+          "memory_sample_count": 3321,
+          "decoded_output_matches_original": true
+        },
+        "Diffusers": {
+          "end_to_end_seconds": 2343.937,
+          "load_seconds": 32.260,
+          "conditioning_seconds": 14.924,
+          "dit_seconds": 2263.720,
+          "video_vae_decode_seconds": 20.679,
+          "audio_vae_decode_seconds": 0.145,
+          "mux_seconds": 4.699,
+          "pytorch_max_allocated_mib": 109960,
+          "pytorch_max_reserved_mib": 110866
+        }
+      }
+    },
+    "two_character_portrait": {
+      "width": 736,
+      "height": 1280,
+      "reference_images": 2,
+      "frameworks": {
+        "edge-dit.cpp": {
+          "end_to_end_seconds": 888.636,
+          "load_seconds": 17.784,
+          "conditioning_seconds": 1.168,
+          "dit_seconds": 811.867,
+          "video_vae_decode_seconds": 41.871,
+          "audio_vae_decode_seconds": 0.355,
+          "save_seconds": 3.737,
+          "peak_device_mib": 52809
+        },
+        "ComfyUI": {
+          "end_to_end_seconds": 1025.864,
+          "conditioning_node_seconds": 33.140,
+          "sampler_node_seconds": 965.504,
+          "video_vae_decode_seconds": 19.947,
+          "audio_vae_decode_seconds": 0.501,
+          "save_seconds": 5.927,
+          "peak_device_mib": 49159
+        },
+        "Diffusers": {
+          "end_to_end_seconds": 1625.178,
+          "load_seconds": 32.838,
+          "conditioning_seconds": 7.176,
+          "dit_seconds": 1553.626,
+          "video_vae_decode_seconds": 20.567,
+          "audio_vae_decode_seconds": 0.144,
+          "mux_seconds": 3.481,
+          "pytorch_max_allocated_mib": 99189,
+          "pytorch_max_reserved_mib": 108646
+        }
+      }
+    }
+  },
+  "reference_resize": {
+    "edge-dit.cpp": "match; no upscaling",
+    "ComfyUI": "match; no upscaling",
+    "Diffusers": "official MiniMaxH3ImageReference; 2048px short edge"
+  }
+}
diff --git a/docs/assets/minimax-h3-ref2va-two-character-edge-comfyui-diffusers-demo.mp4 b/docs/assets/minimax-h3-ref2va-two-character-edge-comfyui-diffusers-demo.mp4
new file mode 100644
index 0000000..25f35d8
Binary files /dev/null and b/docs/assets/minimax-h3-ref2va-two-character-edge-comfyui-diffusers-demo.mp4 differ
diff --git a/docs/cli.md b/docs/cli.md
index 24e6ee8..9fa497f 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -337,12 +337,21 @@ On-load weight type selection:
   --output flux-q4.png
 ```
 
+`--type` is a global loading policy: it applies to every eligible tensor in
+every loaded component (DiT, text encoder, video VAE, and audio VAE). Biases,
+norms, embeddings, protected tensors, and shapes incompatible with a block
+quant remain at their stored type.
+
 Supported `--type` values:
 
 ```text
-f32 f16 bf16 q4_0 q4_1 q5_0 q5_1 q8_0 q2_k q3_k q4_k q5_k q6_k
+preserve f32 f16 bf16 q4_0 q4_1 q5_0 q5_1 q8_0 q2_k q3_k q4_k q5_k q6_k
 ```
 
+`preserve` is the default and leaves every source tensor at its stored type.
+The older value `auto` remains accepted as a compatibility alias for
+`preserve`; it does not perform automatic quantization.
+
 > **Qwen-Image models and FP16:** the Qwen-Image family (`qwen-image`,
 > `qwen-image-edit`, and their distilled/lightning variants) is not supported in
 > FP16 — its DiT activations exceed FP16's dynamic range and silently saturate,
@@ -376,27 +385,36 @@ it off. The offload flags share one semantics — **weights kept on CPU and stag
 to the GPU per compute** (compute always runs on the GPU): `--offload-to-cpu`
 offloads the whole model, while `--dit-offload` / `--text-encoder-offload` /
 `--vae-offload` offload just that one component. `--auto-allocate` places each
-component (DiT, text encoder, VAE) under a hard VRAM cap of `min(--max-vram,
-free)`, keeping a component resident when it fits and offloading (staging) it
-otherwise.
+component (DiT, text encoder, VAE) against a planning budget of
+`min(--max-vram, free)`, keeping a component resident when it fits and
+offloading (staging) it otherwise. By itself this remains a placement-planning
+budget. On single-device CUDA, `--auto-fit --max-vram <GB>` additionally installs a guarded
+allocation ceiling below the requested value, reserving 1 GiB for external
+library workspaces. An allocation that cannot fit is rejected before the
+process crosses the requested ceiling.
 
 These options are workload dependent. Validate output quality and latency for
 the exact model and resolution you plan to run.
 
 ### Budget-driven placement (`--auto-allocate`) and full auto (`--auto-fit`)
 
-Two levels of automation size a run to a hard VRAM budget instead of tuning
+Two levels of automation size a run to a VRAM planning budget instead of tuning
 `--type` and offload flags by hand:
 
 - `--auto-allocate` — you pick the quantization (`--type`); the runtime decides,
   per component (DiT / text encoder / VAE), what stays resident on the GPU and
-  what streams from host, so the peak stays under `--max-vram`.
+  what streams from host. `--max-vram` is not a universal process-level peak clamp.
 - `--auto-fit` — fully automatic. It **implies `--auto-allocate`** and, in
   addition, chooses the quantization itself: the DiT is driven down the ladder
   `q8_0 → q4_k` to the highest level that stays resident within the budget, the
-  text encoder is set to `q8_0` (near-lossless, halves its footprint), and
-  placement is decided as above. `--auto-fit` **ignores `--type`** (it owns the
-  quantization) and logs that it is doing so.
+  text encoder is lowered to at most `q8_0` (an already smaller quant stays unchanged), and
+  placement is decided as above. For the text encoder and DiT, this automatic
+  decision supersedes the global `--type` without ever increasing an already
+  lower-precision source. The VAEs are not replanned: they still follow
+  `--type`, where `preserve` means keeping each source tensor's stored type.
+  With an explicit `--max-vram` on
+  single-device CUDA, it also enables the hard allocation guard; an intrinsically too-large
+  graph fails safely instead of exceeding the budget.
 
 `--auto-fit` measures each component's real compute-buffer footprint at the
 requested resolution (`-W`/`-H`, and `--frames` for video) to size the resident
@@ -416,7 +434,7 @@ the model's fixed 24 fps to the nearest legal `17k+5` frame count. Keep using
 mutually exclusive.
 
 ```bash
-# MiniMax-H3 Q8_0 under a 40 GiB hard placement budget.
+# MiniMax-H3 with automatic quantization/placement and a 40 GiB CUDA ceiling.
 ./build-cuda/bin/ed-cli --video \
   --diffusion-model /path/to/minimax_h3_fl2va-diffusers-Q8_0.gguf \
   --vae /path/to/minimax_h3_video_vae_fp16.safetensors \
diff --git a/docs/minimax-h3.md b/docs/minimax-h3.md
index f910fa6..ab6d883 100644
--- a/docs/minimax-h3.md
+++ b/docs/minimax-h3.md
@@ -21,10 +21,24 @@ last frame. Ref2VA uses the following options:
 | Input | CLI option | Behavior |
 |---|---|---|
 | Image | `--ref-image <path>` | Repeatable; presented as `<Picture N>` |
+| Image sizing | `--ref-image-size match|max` | `match` only downsizes to the output pixel area; `max` resizes to a 2048px short edge, including upscaling, to match official Diffusers geometry (default) |
 | Video | `--ref-video <path>` | Repeatable frame directory or `mp4`/`mov`/`mkv`/`webm`/`avi`; media files require `ffmpeg` |
 | Paired audio | `--ref-video-audio <wav>` | The Nth WAV is paired with the Nth video and overrides embedded audio |
 | Additional audio | `--ref-audio <wav>` | Repeatable; requires at least one image or video reference |
 
+Reference-image resize policy changes both conditioning cost and every Ref2VA
+Transformer step because the encoded reference latents are appended to the DiT
+sequence:
+
+| Mode | Reference-image geometry |
+|---|---|
+| `max` (default) | Scales the short edge to 2048px, including upscaling |
+| `match` | Never upscales; caps the image at the output pixel area |
+
+The selected mode and post-resize reference dimensions affect both conditioning
+cost and DiT sequence length. Use `match` when smaller reference images should
+not be enlarged.
+
 When `--ref-video` points to a media file, the CLI decodes it at 24 fps and
 automatically extracts an embedded audio track. Explicit paired WAV files map
 positionally to videos. Additional audio is numbered after paired or embedded
@@ -35,11 +49,11 @@ options, and audio-only Ref2VA requests are rejected.
 
 ### Downloadable weights
 
-The complete, unpruned checkpoints are recommended for the best quality. Edge
-also supports pruned DiT weights in BF16 safetensors format. Both full and
-pruned BF16 DiTs can be converted to Q8_0 GGUF with `ed-convert`, and the
-resulting Q8_0 DiTs can be loaded directly. Performance and quality results from
-pruned and full DiTs are not directly comparable.
+The complete, unpruned checkpoints are recommended for the best quality.
+edge-dit.cpp also supports pruned DiT weights in BF16 safetensors format. Both
+full and pruned BF16 DiTs can be converted to Q8_0 GGUF with `ed-convert`, and
+the resulting Q8_0 DiTs can be loaded directly. Performance and quality results
+from pruned and full DiTs are not directly comparable.
 
 | Precision | Component | File | Repository |
 |---|---|---|---|
@@ -54,6 +68,12 @@ pruned and full DiTs are not directly comparable.
 | FP16 | Video VAE | `vae/minimax_h3_video_vae_fp16.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
 | FP32 | Audio VAE | `vae/minimax_h3_audio_vae_fp32.safetensors` | [`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3) |
 
+BF16 and FP16 both use 16 bits per weight, so converting the FP16 video VAE to
+BF16 would not reduce its weight memory. With `--type preserve`, `--auto-fit`
+therefore preserves the supplied VAE precision and focuses automatic
+quantization on Qwen3-VL and the DiT. An explicit `--type` still applies to
+eligible VAE tensors.
+
 The official [`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3)
 Diffusers shard indexes are also accepted for BF16 transformer loading. Merged
 Comfy-Org files are usually more convenient for standalone component commands.
@@ -76,10 +96,11 @@ hf download Comfy-Org/MiniMax-H3 \
 
 ### Persistent Q8_0 GGUF
 
-Q8_0 benchmark files are offline conversions of the full BF16 DiTs and Qwen3-VL,
-not Comfy-Org INT8 ConvRot weights. A pruned BF16 DiT can be converted with the
-same command when lower storage and memory usage are preferred. Convert once
-with `ed-convert` instead of quantizing during every model load:
+Create persistent Q8_0 GGUF files from the BF16 DiTs and Qwen3-VL. The INT8
+ConvRot safetensors use a different representation and are not interchangeable
+with GGUF Q8_0. A pruned BF16 DiT can be converted with the same command when
+lower storage and memory usage are preferred. Convert once with `ed-convert`
+instead of quantizing during every model load:
 
 ```bash
 ed-convert --model models/minimax-h3/diffusion_models/minimax_h3_fl2va_bf16.safetensors \
@@ -129,6 +150,7 @@ point them to the converted GGUF files.
 ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
   --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
   --video-duration 5 -W 864 -H 480 --steps 20 --cfg-scale 1 \
+  --sampler res_multistep --scheduler simple \
   --prompt "A cinematic sunset over layered mountain ridges with quiet natural ambience." \
   --video-format mp4 --output t2va.mp4
 
@@ -136,6 +158,7 @@ ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
 ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
   --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" --image first.png \
   --video-duration 5 -W 864 -H 480 --steps 20 --cfg-scale 1 \
+  --sampler res_multistep --scheduler simple \
   --prompt "Starting from <Picture 1>, preserve the scene and add subtle natural motion." \
   --video-format mp4 --output i2va.mp4
 
@@ -147,19 +170,25 @@ ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
 
 Use the Ref2VA DiT for all commands in this section.
 
+For the recommended MiniMax-H3 sampling path, use `res_multistep` with the
+`simple` sigma schedule. The default remains `euler` with `discrete` for
+compatibility with existing edge-dit.cpp commands.
+
 ```bash
 # Image reference
 ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
   --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
   --ref-image reference.png --video-duration 5 -W 864 -H 480 --steps 20 \
-  --cfg-scale 1 --prompt "Use <Picture 1> as the strict visual reference." \
+  --cfg-scale 1 --sampler res_multistep --scheduler simple \
+  --prompt "Use <Picture 1> as the strict visual reference." \
   --video-format mp4 --output ref-image.mp4
 
 # MP4 reference; embedded audio is paired automatically when present
 ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
   --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
   --ref-video reference.mp4 --video-duration 5 -W 864 -H 480 --steps 20 \
-  --cfg-scale 1 --prompt "Preserve <Video 1> and its <Audio 1> throughout the result." \
+  --cfg-scale 1 --sampler res_multistep --scheduler simple \
+  --prompt "Preserve <Video 1> and its <Audio 1> throughout the result." \
   --video-format mp4 --output ref-video.mp4
 
 # Frame directory with explicit paired audio
@@ -167,6 +196,7 @@ ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
   --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
   --ref-video reference-frames --ref-video-audio soundtrack.wav \
   --video-duration 5 -W 864 -H 480 --steps 20 --cfg-scale 1 \
+  --sampler res_multistep --scheduler simple \
   --prompt "Preserve <Video 1> and synchronize it with <Audio 1>." \
   --video-format mp4 --output ref-video-audio.mp4
 
@@ -175,6 +205,7 @@ ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
   --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
   --ref-image reference.png --ref-video reference.mp4 --ref-audio music.wav \
   --video-duration 5 -W 864 -H 480 --steps 20 --cfg-scale 1 \
+  --sampler res_multistep --scheduler simple \
   --prompt "Use <Video 1>, <Picture 1>, and every supplied audio reference in a natural transition." \
   --video-format mp4 --output ref-mixed.mp4
 ```
@@ -190,10 +221,30 @@ Qwen3-VL, video VAE, and audio VAE while retaining CUDA compute.
 ed-cli --video --diffusion-model "$DIT" --llm "$LLM" \
   --vae "$VIDEO_VAE" --audio-vae "$AUDIO_VAE" \
   --auto-fit --max-vram 40 --video-duration 5 -W 864 -H 480 --steps 20 \
-  --cfg-scale 1 --prompt "A cinematic sunset over layered mountain ridges." \
+  --cfg-scale 1 --sampler res_multistep --scheduler simple \
+  --prompt "A cinematic sunset over layered mountain ridges." \
   --video-format mp4 --output auto-fit.mp4
 ```
 
+For long Ref2VA jobs on GPUs that can hold one major component at a time,
+`--auto-fit --max-vram` automatically uses the MiniMax-H3 staged lifecycle.
+Resident components are staged serially: Qwen is loaded only for positive and
+negative context encoding, then released before the video VAE encodes visual
+references; the video VAE is then released before the audio VAE encodes paired
+or standalone reference audio. DiT weights are staged for denoising and released
+before the video and audio VAEs are loaded again for final decode. Components
+that cannot fit as a whole remain layer/graph-segment offloaded instead. The
+explicit `--minimax-h3-stage-lifecycle` option enables the same phase behavior
+without `--auto-fit`.
+
+On single-device CUDA, the combined `--auto-fit --max-vram 24` mode installs a guarded
+allocation ceiling below 24 GiB and reserves 1 GiB for CUDA/cuDNN workspaces.
+Automatic quantization, phase lifecycle, component placement, and graph
+segmentation are attempted first. If the workload's minimum graph segment still
+cannot fit, generation fails before crossing the requested 24 GiB ceiling.
+`--max-vram` without `--auto-fit` remains a planning input rather than this hard
+allocation guard.
+
 MiniMax-H3 always uses its fixed `16x16` video-VAE tiling path. Generic
 `--vae-tiling` and `--vae-tile-size` values do not replace this model-specific
 layout.
@@ -242,11 +293,11 @@ within the 24 GB limit.
 ## H200 BF16 comparison
 
 The tables below use one H200, resident components, `864x480`, 124 frames at
-24 fps, 20 steps, CFG 1, and seed `424242`. Edge uses the complete Comfy-Org
-BF16 DiT/Qwen files, FP16 video VAE, and FP32 audio VAE. Diffusers uses the
+24 fps, 20 steps, CFG 1, and seed `424242`. edge-dit.cpp uses the complete
+Comfy-Org BF16 DiT/Qwen files, FP16 video VAE, and FP32 audio VAE. Diffusers uses the
 official complete BF16 DiT shards, BF16 Qwen3-VL, and its FP32 VAEs. “Generate”
 excludes model loading, output muxing, and process cleanup. Peak VRAM is sampled
-over the complete process. Values are `Edge / Diffusers`.
+over the complete process. Values are `edge-dit.cpp / Diffusers`.
 
 FL2VA does not use Ref2VA resize preprocessing:
 
@@ -259,12 +310,13 @@ FL2VA does not use Ref2VA resize preprocessing:
 
 ### Ref2VA
 
-Current preprocessing follows Diffusers geometry: image short edge 2048;
-video short edge 768 with a pre-rounding `768x1344` area cap; preserved aspect
-ratio; dimensions rounded to multiples of 32; Lanczos resize. Edge is faster
-than Diffusers in all four measured Ref2VA generation paths:
+These benchmark rows use Edge-DiT.cpp `--ref-image-size max`, matching the
+official Diffusers image geometry: image short edge 2048; video short edge 768
+with a pre-rounding `768x1344` area cap; preserved aspect ratio; dimensions
+rounded to multiples of 32; Lanczos resize. Edge-DiT.cpp is faster than
+Diffusers in all four measured Ref2VA generation paths:
 
-| Current task | Generate | Edge speedup | Peak VRAM |
+| Current task | Generate | edge-dit.cpp speedup | Peak VRAM |
 |---|---:|---:|---:|
 | Image | 126.915s / 136.656s | 1.08x | 130,445 / 139,253 MiB |
 | MP4 video / video frames † | 182.649s / 183.921s | 1.01x | 132,661 / 137,161 MiB |
@@ -273,11 +325,121 @@ than Diffusers in all four measured Ref2VA generation paths:
 
 The image row is a strict same-image, same-prompt comparison. The
 mixed-reference path has a clear 1.06x lead. The two video rows retain smaller
-1.01x measured leads; they are marked † because the MP4 run lets Edge extract
-embedded audio while the Diffusers run uses decoded video frames, and the
+1.01x measured leads; they are marked † because the MP4 run lets edge-dit.cpp
+extract embedded audio while the Diffusers run uses decoded video frames, and the
 paired-audio prompts differ slightly. A locked-command rerun is required before
 treating the approximately 1% margins as statistically significant.
 
+#### H200 15-second multi-reference comparison
+
+The following longer Ref2VA runs are a separate benchmark from the BF16 tables
+above. They compare two reference-image-heavy prompts across edge-dit.cpp,
+ComfyUI, and Diffusers on one H200. The four-image action task uses `1280x736`;
+the two-character portrait task uses `736x1280`. Both generate 362 frames at
+24 fps (approximately 15.08 seconds), with 20 steps, CFG 1, seed
+`157368968253448`, and `res_multistep`/`simple`. Each task uses the same prompt,
+reference images in the same order, output canvas, frame count, and sampling
+parameters across all three frameworks.
+
+These dimensions are not `768x1344` and are not a MiniMax-H3 requirement. The
+experiment preserved the submitted UI workflow configuration: a 0.9-megapixel
+`ResolutionSelector`, 16:9 or 9:16 aspect ratio, and dimensions aligned to a
+multiple of 32. That configuration resolves to `1280x736` or `736x1280`. The
+parameters were retained so all three frameworks could replay the actual task;
+therefore these results must not be compared directly with an older
+`768x1344` run.
+
+Outputs:
+
+- [Four-image action three-framework comparison](assets/minimax-h3-ref2va-four-image-edge-comfyui-diffusers-demo.mp4)
+- [Two-character portrait three-framework comparison](assets/minimax-h3-ref2va-two-character-edge-comfyui-diffusers-demo.mp4)
+- [Machine-readable benchmark metrics](assets/minimax-h3-ref2va-h200-15s-metrics.json)
+
+The linked comparison videos are compressed documentation assets tracked in the
+repository. Full-resolution per-framework outputs remain benchmark artifacts
+rather than source-tree dependencies.
+
+The three frameworks use their practical quantized representations rather than
+byte-identical weights:
+
+| Framework | Ref2VA DiT | Qwen3-VL | Video / audio VAE |
+|---|---|---|---|
+| edge-dit.cpp | Pruned Q8_0 GGUF | Q4_K_M GGUF | FP16 / FP32 |
+| ComfyUI | Pruned INT8 ConvRot | NVFP4 AWQ | FP16 / FP32 |
+| Diffusers | Official full weights with TorchAO weight-only INT8 | Official weights with TorchAO weight-only INT8 | FP16 / FP32 |
+
+End-to-end wall time includes loading, conditioning, generation, decode, and
+saving. edge-dit.cpp and ComfyUI peaks are device-level samples; Diffusers only
+recorded PyTorch allocator peaks, so its allocated/reserved values are shown
+separately.
+
+| Task | Framework | End-to-end | Peak VRAM |
+|---|---|---:|---:|
+| Four-image action | edge-dit.cpp | **919.765s** | **52,667 MiB (51.43 GiB)** |
+| Four-image action | ComfyUI | 1055.354s | **49,413 MiB (48.25 GiB)** |
+| Four-image action | Diffusers | 2343.937s | 107.38 GiB allocated / 108.27 GiB reserved |
+| Two-character portrait | edge-dit.cpp | **888.636s** | 52,809 MiB (51.57 GiB) |
+| Two-character portrait | ComfyUI | 1025.864s | **49,159 MiB (48.01 GiB)** |
+| Two-character portrait | Diffusers | 1625.178s | 96.86 GiB allocated / 106.10 GiB reserved |
+
+Four-image action stage times:
+
+| Stage | edge-dit.cpp | ComfyUI | Diffusers |
+|---|---:|---:|---:|
+| Load / initialization | 17.773s | Not isolated | 32.260s |
+| Text, image, and reference-VAE conditioning | 2.641s | Not isolated | 14.924s |
+| DiT / sampling | **839.890s** | Not isolated | 2263.720s |
+| Video VAE decode | 41.842s | Not isolated | **20.679s** |
+| Audio VAE decode | 0.369s | Not isolated | **0.145s** |
+| Save / mux | 5.519s | Not isolated | **4.699s** |
+| End-to-end | **919.765s** | 1055.354s | 2343.937s |
+
+The profiled four-image ComfyUI rerun collected 3,321 device-memory samples at
+0.2-second intervals from a zero-MiB baseline and measured a 49,413 MiB peak.
+Its decoded video frames and PCM audio are bit-identical to the original
+1070.928-second run. The historical run did not retain a node-level profile, so
+unavailable stage values are intentionally not reconstructed. A separate
+constrained rerun completed in 1059.844s with an observed 22,789 MiB peak under
+a 24 GiB limit and produced the same decoded frames and audio.
+
+Two-character portrait stage times:
+
+| Stage | edge-dit.cpp | ComfyUI | Diffusers |
+|---|---:|---:|---:|
+| Load / initialization | 17.784s | Deferred; not independently comparable | 32.838s |
+| Text, image, and reference-VAE conditioning | **1.168s** | 33.140s | 7.176s |
+| DiT / sampling | **811.867s** | 965.504s | 1553.626s |
+| Video VAE decode | 41.871s | **19.947s** | 20.567s |
+| Audio VAE decode | 0.355s | 0.501s | **0.144s** |
+| Save / mux | 3.737s | 5.927s | **3.481s** |
+| End-to-end | **888.636s** | 1025.864s | 1625.178s |
+
+ComfyUI's conditioning and sampler nodes include deferred model staging and are
+not pure kernel timings. The edge-dit.cpp phase peaks were sampled at 0.2-second
+intervals:
+
+| edge-dit.cpp phase | Four-image action | Two-character portrait |
+|---|---:|---:|
+| Load | 19,481 MiB | 615 MiB |
+| Conditioning / text context | 22,675 MiB | 20,563 MiB |
+| Reference video-VAE encode | Included above | 5,827 MiB |
+| DiT / sampling | **52,667 MiB** | **52,809 MiB** |
+| Decode | 37,521 MiB | 37,521 MiB |
+| Save | 32,373 MiB | 32,515 MiB |
+
+Reference preprocessing is an important limitation of this comparison.
+edge-dit.cpp and the captured ComfyUI workflow use `ref_image_size=match`, which
+does not upscale the small source images. Diffusers uses the official
+`MiniMaxH3ImageReference` path and enlarges every reference image to a 2048px
+short edge. For the four-image task, edge-dit.cpp/ComfyUI use `512x320`,
+`576x320`, `512x288`, and `512x288`, while Diffusers uses `3232x2048`,
+`3648x2048`, `3648x2048`, and `3648x2048`. For the two-character task, the
+respective sizes are `416x224` and `416x224` versus `3488x2048` and
+`3616x2048`. Diffusers therefore processes substantially longer reference
+sequences, increasing conditioning time, every DiT step, and peak memory. The
+table is useful as an actual-workflow result and quality comparison, but it is
+not a same-compute kernel benchmark.
+
 ## Limitations
 
 - Reference adherence is prompt dependent. Name `<Picture N>`, `<Video N>`, and
diff --git a/docs/models.md b/docs/models.md
index d2ae828..d80f9eb 100644
--- a/docs/models.md
+++ b/docs/models.md
@@ -169,6 +169,27 @@ Per-tensor overrides are available with:
 --tensor-type-rules "attn=q4_0,norm=f16"
 ```
 
+Component files keep independent stored precisions when `--type preserve` (the
+default; legacy alias `auto`) is used. A quantized DiT GGUF can therefore be combined with a
+different Qwen/text-encoder GGUF and floating-point video/audio VAEs, provided
+the files belong to the same model family. The precision policy is:
+
+| Configuration | Precision behavior |
+|---|---|
+| Separate component files + `--type preserve` | Every component and tensor keeps its stored precision (`auto` is a compatibility alias) |
+| Explicit `--type` | Applies one requested type to every eligible tensor in every loaded component |
+| `--tensor-type-rules` | Overrides eligible tensors by name/regex, including component-prefix-specific rules |
+| `--auto-fit --max-vram` | Independently selects text-encoder and DiT quantization without increasing lower-precision inputs; VAEs still follow `--type` (`preserve` keeps stored representation) |
+
+Loadable precision is not the same as accelerated precision. CUDA dense linear
+layers use floating-point cuBLAS or quantized MMQ/dequantization paths according
+to tensor type and shape. F32/F16/BF16 VAE convolutions have native CUDA/cuDNN
+paths, but block-quantized VAE convolution weights do not provide native Q4/Q8
+convolution acceleration and may be converted or fall back. Biases, norms,
+embeddings, incompatible tensor shapes, and numerically protected tensors also
+remain floating point. Thus supported component precisions may be mixed freely,
+but not every theoretical mixture makes every operator faster.
+
 Memory-oriented options:
 
 ```bash
@@ -186,11 +207,17 @@ Memory-oriented options:
 `--vae-tiling` takes an explicit `on|off|auto` value. Under `--auto-allocate`
 with a `--max-vram` budget, the runtime decides per component (diffusion
 transformer, text encoder, VAE) what stays resident on the GPU and what streams
-from host memory, so large models can run within a fixed VRAM budget.
+from host memory. `--auto-allocate` alone uses a placement and graph-planning
+budget rather than a hard process-memory limit.
 `--auto-fit` goes one step further — a superset of `--auto-allocate` that also
-picks the quantization to fit the budget (text encoders forced to `q8_0`, the
-diffusion transformer walking a `q8_0 → q4_K` ladder), ignoring `--type`; use it
-to fit a hard VRAM cap without hand-tuning quantization and placement.
+picks the quantization to fit the budget (text encoders lowered toward `q8_0`
+without increasing already lower quantization, and the diffusion transformer
+walking a `q8_0 → q4_K` ladder). This decision supersedes `--type` for the text
+encoder and DiT only; VAEs continue to follow the requested global type. Use it
+to fit a VRAM budget without hand-tuning quantization and placement. On single-device CUDA,
+an explicit `--auto-fit --max-vram <GB>` also enables a guarded allocation
+ceiling with reserved external-library headroom. A workload whose minimum graph
+segment cannot fit fails before crossing the requested ceiling.
 
 See [Command line usage](cli.md#quantization-and-memory) for runnable examples
 and [performance (H200)](performance-H200.md) for cache, parallelism, and
diff --git a/docs/optimization/memory-efficient-execution.md b/docs/optimization/memory-efficient-execution.md
index 750e181..cf1e8da 100644
--- a/docs/optimization/memory-efficient-execution.md
+++ b/docs/optimization/memory-efficient-execution.md
@@ -149,14 +149,15 @@ well — either `--offload-to-cpu` (full-model offload) or add `--dit-offload`.
 ### Automatic placement (`--auto-allocate`)
 
 Rather than deciding offload per component by hand, `--auto-allocate` fits
-components against a hard VRAM budget of `min(--max-vram, live free VRAM)`.
+components against a VRAM planning budget of `min(--max-vram, live free VRAM)`.
 Components are considered in priority order — diffusion transformer, then text
 encoders, then VAE — and each is placed resident on the GPU if its
 (post-quantization) weights plus a compute-headroom reserve still fit the
 remaining budget; otherwise it is offloaded. After placement, the leftover
 budget becomes the graph VRAM budget (Section 4) for whatever was offloaded, so
 the largest, most-reused weights get first claim on resident VRAM and the rest
-is graph-segmented to stay within the cap.
+is graph-segmented to stay within the graph budget. Backend-owned CUDA/cuDNN
+workspaces may still make the measured process peak higher than `--max-vram`.
 
 ### Fully automatic budgeting (`--auto-fit`)
 
@@ -165,7 +166,8 @@ placement, so one flag covers the whole budget. On top of the resident/offload
 decision, `--auto-fit` also **chooses the quantization** to make components fit,
 ignoring `--type`:
 
-- the text encoders are forced to `q8_0` unconditionally — TE compute time is
+- text encoders above `q8_0` are lowered to `q8_0`; an input already below
+  `q8_0` keeps its existing quantization — TE compute time is
   negligible next to the DiT, so `q8_0` is near-lossless yet frees the budget
   that a bf16 TE (FLUX's T5 alone is ~9 GB) would otherwise consume;
 - the diffusion transformer walks a `q8_0 → q4_K` ladder, picking the highest
@@ -173,7 +175,7 @@ ignoring `--type`:
   fit, it stays at `q8_0` and is offloaded (an offloaded `q8_0` beats a `q4_K`
   that would have to offload anyway).
 
-Use `--auto-fit` when you just want a model to fit a hard VRAM cap without
+Use `--auto-fit` when you want automatic quantization and placement without
 hand-tuning `--type` and placement; use `--auto-allocate` when you want to keep
 control of the quantization (`--type`) and only automate placement.
 
@@ -298,8 +300,8 @@ exact model and resolution being targeted.
 | `--dit-offload` | Keep diffusion-transformer weights in CPU memory and stage them onto the GPU per step (compute runs on the GPU) |
 | `--text-encoder-offload` | Keep text-encoder weights in CPU memory and stage them onto the GPU per encode (compute runs on the GPU) |
 | `--vae-offload` | Keep VAE weights in CPU memory and stage them onto the GPU per decode (compute runs on the GPU) |
-| `--auto-allocate` | Budget-capped automatic placement: fit components (DiT, then text encoders, then VAE) resident on the GPU under a hard `min(--max-vram, free VRAM)` cap, offloading and graph-segmenting whatever does not fit |
-| `--auto-fit` | Superset of `--auto-allocate`: also chooses quantization to fit the budget (text encoders forced to `q8_0`, DiT walks a `q8_0 → q4_K` ladder), ignoring `--type` |
+| `--auto-allocate` | Budget-driven automatic placement: fit components (DiT, then text encoders, then VAE) against `min(--max-vram, free VRAM)`, offloading and graph-segmenting whatever does not fit; external backend workspaces can raise the measured process peak |
+| `--auto-fit` | Superset of `--auto-allocate`: also chooses quantization to fit the budget (text encoders are lowered to at most `q8_0`, DiT walks a `q8_0 → q4_K` ladder), ignoring `--type` |
 | `--max-vram <GB>` | Compute-graph VRAM budget; drives graph-cut segmentation. Used with offload or `--auto-allocate`; when offload is set without it, the runtime defaults to `0.85 × free VRAM` |
 | `--vae-tiling <on\|off\|auto>` | VAE tiling: `on` forces it, `off` forces it off (suppressing the low-VRAM auto-enable), `auto` (the default) enables it only on lower-VRAM GPUs (<=25 GiB total) |
 | `--vae-tile-size <float>` | Enable VAE tiling and set the relative tile size (larger value = finer grid) |
diff --git a/docs/optimization/model-representation-and-precision.md b/docs/optimization/model-representation-and-precision.md
index cbedfb9..2c1367e 100644
--- a/docs/optimization/model-representation-and-precision.md
+++ b/docs/optimization/model-representation-and-precision.md
@@ -54,9 +54,10 @@ with shared scaling metadata. A quantized type can therefore only be applied to
 a tensor whose leading dimension is a multiple of the block size; other tensors
 are kept at their stored type.
 
-The default weight type is `auto`. In this mode edge-dit.cpp does not change the
-stored representation: each weight keeps the data type present in the source
-checkpoint. Selecting an explicit type opts into conversion during loading.
+The default weight type is `preserve`. In this mode edge-dit.cpp does not change
+the stored representation: each weight keeps the data type present in the source
+checkpoint. The older name `auto` remains accepted as a compatibility alias.
+Selecting an explicit type opts into conversion during loading.
 
 ---
 
@@ -199,7 +200,7 @@ and explicit `--tensor-type-rules` targeting these tensors are left untouched.
 
 | Flag | Effect |
 |---|---|
-| `--type <dtype>` (alias `--weight-type`) | Global weight type; accepts `auto`, `f32`, `f16`, `bf16`, and the `q*` types |
+| `--type <dtype>` (alias `--weight-type`) | Global weight policy; accepts `preserve`, `f32`, `f16`, `bf16`, and the `q*` types (`auto` aliases `preserve`) |
 | `--tensor-type-rules <csv>` | Comma-separated `<name-regex>=<ggml-type>` overrides |
 
 ### C API
diff --git a/examples/cli/cli_common.hpp b/examples/cli/cli_common.hpp
index ae1ccce..7c7d08e 100644
--- a/examples/cli/cli_common.hpp
+++ b/examples/cli/cli_common.hpp
@@ -396,7 +396,7 @@ inline ed_dtype_t parse_weight_type(const char* text, bool* ok) {
         }
     }
 
-    if (type == "auto" || type.empty()) {
+    if (type == "preserve" || type == "auto" || type.empty()) {
         return ED_DTYPE_AUTO;
     }
     if (type == "f32" || type == "fp32") {
@@ -465,6 +465,7 @@ struct FluxCliArgs {
     const char* image_path = nullptr;
     const char* end_image_path = nullptr;
     std::vector<std::string> ref_image_paths;
+    ed_ref_image_size_t ref_image_size = ED_REF_IMAGE_SIZE_MAX;
     std::vector<std::string> ref_video_paths;
     std::vector<std::string> ref_video_audio_paths;
     std::vector<std::string> ref_audio_paths;
@@ -498,6 +499,8 @@ struct FluxCliArgs {
     float guidance = 3.5f;
     float cfg_scale = 1.0f;
     float flow_shift = 0.0f;
+    ed_sampler_t sampler = ED_SAMPLER_AUTO;
+    ed_scheduler_t scheduler = ED_SCHEDULER_AUTO;
 
     ed_cache_mode_t cache_mode = ED_CACHE_DISABLED;
     float cache_reuse_threshold = std::numeric_limits<float>::infinity();
@@ -525,6 +528,7 @@ struct FluxCliArgs {
     bool offload_to_cpu = false;
     bool text_encoder_offload = false;
     bool dit_offload = false;
+    bool minimax_h3_stage_lifecycle = false;
     bool auto_allocate = false;
     bool auto_fit = false;
     bool vae_offload = false;
@@ -631,6 +635,17 @@ inline bool parse_args(int argc, char** argv, FluxCliArgs* args) {
             const char* path = require_value(key);
             if (!path) return false;
             args->ref_image_paths.emplace_back(path);
+        } else if (std::strcmp(key, "--ref-image-size") == 0 || std::strcmp(key, "--ref_image_size") == 0) {
+            const char* value = require_value(key);
+            if (!value) return false;
+            if (std::strcmp(value, "match") == 0) {
+                args->ref_image_size = ED_REF_IMAGE_SIZE_MATCH;
+            } else if (std::strcmp(value, "max") == 0) {
+                args->ref_image_size = ED_REF_IMAGE_SIZE_MAX;
+            } else {
+                std::fprintf(stderr, "invalid %s value '%s'; expected match or max\n", key, value);
+                return false;
+            }
         } else if (std::strcmp(key, "--ref-video") == 0 || std::strcmp(key, "--ref_video") == 0) {
             const char* path = require_value(key);
             if (!path) return false;
@@ -696,6 +711,32 @@ inline bool parse_args(int argc, char** argv, FluxCliArgs* args) {
             const char* v = require_value(key);
             if (!v) return false;
             args->flow_shift = parse_float_value(v, args->flow_shift);
+        } else if (std::strcmp(key, "--sampler") == 0 || std::strcmp(key, "--sampling-method") == 0) {
+            const char* value = require_value(key);
+            if (!value) return false;
+            if (std::strcmp(value, "auto") == 0) {
+                args->sampler = ED_SAMPLER_AUTO;
+            } else if (std::strcmp(value, "euler") == 0) {
+                args->sampler = ED_SAMPLER_EULER;
+            } else if (std::strcmp(value, "res_multistep") == 0 || std::strcmp(value, "res-multistep") == 0) {
+                args->sampler = ED_SAMPLER_RES_MULTISTEP;
+            } else {
+                std::fprintf(stderr, "invalid %s value '%s'; expected auto, euler, or res_multistep\n", key, value);
+                return false;
+            }
+        } else if (std::strcmp(key, "--scheduler") == 0) {
+            const char* value = require_value(key);
+            if (!value) return false;
+            if (std::strcmp(value, "auto") == 0) {
+                args->scheduler = ED_SCHEDULER_AUTO;
+            } else if (std::strcmp(value, "discrete") == 0) {
+                args->scheduler = ED_SCHEDULER_DISCRETE;
+            } else if (std::strcmp(value, "simple") == 0) {
+                args->scheduler = ED_SCHEDULER_SIMPLE;
+            } else {
+                std::fprintf(stderr, "invalid %s value '%s'; expected auto, discrete, or simple\n", key, value);
+                return false;
+            }
         } else if (std::strcmp(key, "--start_index") == 0 || std::strcmp(key, "--start-index") == 0) {
             const char* v = require_value(key);
             if (!v) return false;
@@ -840,6 +881,8 @@ inline bool parse_args(int argc, char** argv, FluxCliArgs* args) {
             args->text_encoder_offload = true;
         } else if (std::strcmp(key, "--dit-offload") == 0) {
             args->dit_offload = true;
+        } else if (std::strcmp(key, "--minimax-h3-stage-lifecycle") == 0) {
+            args->minimax_h3_stage_lifecycle = true;
         } else if (std::strcmp(key, "--auto-allocate") == 0) {
             args->auto_allocate = true;
         } else if (std::strcmp(key, "--auto-fit") == 0) {
diff --git a/examples/cli/main.cpp b/examples/cli/main.cpp
index 6dfb294..0fc3b69 100644
--- a/examples/cli/main.cpp
+++ b/examples/cli/main.cpp
@@ -107,6 +107,7 @@ static void print_usage(const char* prog) {
         "  --video-duration <seconds>  MiniMax-H3 duration; aligns to 17k+5 frames\n"
         "  --fps <int>               Video fps, default: 16\n"
         "  --ref-image <path>        MiniMax-H3 Ref2VA reference image; repeatable\n"
+        "  --ref-image-size <mode>   Reference image sizing: match or max, default: max\n"
         "  --ref-video <path>        MiniMax-H3 Ref2VA reference video frames directory or media file; repeatable\n"
         "                            Media files are decoded with ffmpeg; embedded audio is paired automatically\n"
         "  --ref-video-audio <path>  WAV soundtrack paired with the corresponding --ref-video\n"
@@ -117,6 +118,8 @@ static void print_usage(const char* prog) {
         "  --guidance <float>        Flux distilled guidance, default: 3.5\n"
         "  --cfg-scale <float>       Classifier-free guidance scale, default: 1.0\n"
         "  --flow-shift <float>      Flow scheduler shift, default: model default\n"
+        "  --sampler <name>          Sampling method: auto, euler, res_multistep\n"
+        "  --scheduler <name>        Sigma scheduler: auto, discrete, simple\n"
         "  --cache <mode>            Cache mode: off, easycache, ucache, dbcache, taylorseer, cache-dit, magcache, dicache, sencache\n"
         "  --cache-threshold <float> EasyCache/UCache reuse threshold\n"
         "  --cache-start <float>     Cache active window start percent, default: 0.15\n"
@@ -152,7 +155,9 @@ static void print_usage(const char* prog) {
         "  --gpu                     Alias for --backend gpu\n"
         "  --devices <csv>           GPU devices for parallel workers, e.g. 0,1,2,3\n"
         "  --type <dtype>            Weight type / on-the-fly quantization when loading safetensors:\n"
-        "                            f32, f16, bf16, q4_0, q4_1, q5_0, q5_1, q8_0, q2_k, q3_k, q4_k, q5_k, q6_k. Default: auto\n"
+        "                            preserve, f32, f16, bf16, q4_0, q4_1, q5_0, q5_1, q8_0,\n"
+        "                            q2_k, q3_k, q4_k, q5_k, q6_k. Default: preserve\n"
+        "                            ('auto' remains accepted as a compatibility alias)\n"
         "  --tensor-type-rules <csv> Per-tensor quant overrides (mixed quant), e.g. \"attn=q4_0,norm=f16\"\n"
         "                            Each rule is <name-regex>=<ggml-type-name>, comma-separated\n"
         "  --no-t5                   Skip loading T5XXL text encoder (SD3 only; reduces memory, degrades prompt adherence)\n"
@@ -161,14 +166,19 @@ static void print_usage(const char* prog) {
         "  --offload-to-cpu          Keep model weights on CPU, copy to GPU per-compute (saves VRAM)\n"
         "  --dit-offload             Keep DiT weights on CPU, stage to GPU per step (compute on GPU)\n"
         "  --text-encoder-offload    Keep text-encoder weights on CPU, stage to GPU per encode (compute on GPU)\n"
+        "  --minimax-h3-stage-lifecycle  MiniMax-H3: stage Qwen/VAE by phase and release them during DiT\n"
         "  --vae-offload             Keep VAE weights on CPU, stage to GPU per decode (compute on GPU)\n"
-        "  --max-vram <GB>           Limit VRAM usage for compute graphs (e.g. 8.0)\n"
-        "  --auto-allocate           Auto per-component placement under a hard VRAM cap\n"
+        "  --max-vram <GB>           Set the VRAM planning budget; with --auto-fit on\n"
+        "                            single-device CUDA, also enforce a guarded allocation ceiling\n"
+        "  --auto-allocate           Auto per-component placement under a VRAM planning budget\n"
         "                            = min(--max-vram, free); keeps components resident\n"
         "                            when they fit, offloads (segments) the rest\n"
-        "  --auto-fit                Fully automatic: choose DiT quantization (q8_0 down\n"
-        "                            to q4_k) AND placement to fit the VRAM budget.\n"
-        "                            Implies --auto-allocate; ignores --type. Off by default.\n"
+        "                            (external CUDA workspaces can raise the process peak)\n"
+        "  --auto-fit                Fully automatic: choose TE/DiT quantization (DiT q8_0\n"
+        "                            down to q4_k) AND placement to fit the VRAM budget.\n"
+        "                            Implies --auto-allocate; replans TE/DiT precision while\n"
+        "                            --type still controls VAE precision. With --max-vram,\n"
+        "                            oversized workloads fail safely. Off by default.\n"
         "  --flash-attention         Enable flash attention, default: on\n"
         "  --no-flash-attention      Disable flash attention\n"
         "  --cfg-parallel-size <n>   Split CFG cond/uncond branches across n GPUs, currently supports 1 or 2\n"
@@ -892,6 +902,7 @@ int main(int argc, char** argv) {
     ctx_params.offload_params_to_cpu = args.offload_to_cpu;
     ctx_params.dit_offload = args.dit_offload;
     ctx_params.text_encoder_offload = args.text_encoder_offload;
+    ctx_params.minimax_h3_stage_lifecycle = args.minimax_h3_stage_lifecycle;
     ctx_params.auto_allocate = args.auto_allocate;
     ctx_params.auto_fit = args.auto_fit;
     // For auto-allocate/auto-fit compute-buffer measurement: use the requested
@@ -995,8 +1006,9 @@ int main(int argc, char** argv) {
         gen_params.height = args.height;
         gen_params.frames = generation_frames;
         gen_params.seed = args.seed;
-        gen_params.sample.sampler = ED_SAMPLER_AUTO;
-        gen_params.sample.scheduler = ED_SCHEDULER_AUTO;
+        gen_params.ref_image_size = args.ref_image_size;
+        gen_params.sample.sampler = args.sampler;
+        gen_params.sample.scheduler = args.scheduler;
         gen_params.sample.steps = args.steps;
         gen_params.sample.cfg_scale = args.cfg_scale;
         gen_params.sample.image_cfg_scale = 1.0f;
@@ -1159,8 +1171,8 @@ int main(int argc, char** argv) {
          * - set cfg_scale to 1.0 to avoid the traditional CFG negative-conditioning branch
          * - use the common Flux value of 3.5 for distilled_guidance
          */
-        gen_params.sample.sampler = ED_SAMPLER_AUTO;
-        gen_params.sample.scheduler = ED_SCHEDULER_AUTO;
+        gen_params.sample.sampler = args.sampler;
+        gen_params.sample.scheduler = args.scheduler;
         gen_params.sample.steps = args.steps;
         gen_params.sample.cfg_scale = args.cfg_scale;
         gen_params.sample.image_cfg_scale = 1.0f;
diff --git a/examples/cli/sample_main.cpp b/examples/cli/sample_main.cpp
index 469afaf..284030e 100644
--- a/examples/cli/sample_main.cpp
+++ b/examples/cli/sample_main.cpp
@@ -70,6 +70,8 @@ void print_usage(const char* prog) {
         "  --guidance_scale <float>  Flux distilled guidance. Default 3.5\n"
         "  --cfg_scale <float>       Classifier-free guidance scale. Default 1.0\n"
         "  --flow_shift <float>      Flow scheduler shift. Default model default\n"
+        "  --sampler <name>          Sampling method: auto, euler, res_multistep\n"
+        "  --scheduler <name>        Sigma scheduler: auto, discrete, simple\n"
         "  --negative_prompt <text>  Negative prompt (used when cfg_scale != 1). Default empty\n"
         "  --image <path>            Input/reference image for image-editing models\n"
         "  --video, -M vid_gen       Generate video frames (calls ed_generate_video; writes .avi)\n"
@@ -80,15 +82,17 @@ void print_usage(const char* prog) {
         "  --end_index <int>         Last prompt index (exclusive). Default all\n"
         "  --threads <int>           CPU thread count. Default auto\n"
         "  --backend <name>          auto|cpu|cuda|vulkan|metal|gpu. Default auto\n"
+        "  --type <dtype>            Global weight policy. Default preserve ('auto' is an alias)\n"
         "  --no-flash-attention      Disable flash attention\n\n"
         "Memory / offload:\n"
         "  --offload-to-cpu          Full offload: all weights on CPU, staged to GPU per compute\n"
         "  --dit-offload             DiT weights on CPU, staged to GPU per step (compute on GPU)\n"
         "  --text-encoder-offload    Text-encoder weights on CPU, staged to GPU per encode\n"
+        "  --minimax-h3-stage-lifecycle  MiniMax-H3: stage Qwen/VAE by phase and release them during DiT\n"
         "  --vae-offload             VAE weights on CPU, staged to GPU per decode\n"
-        "  --max-vram <GB>           Limit compute-graph VRAM (segments the graph). Implies --auto-allocate path\n"
-        "  --auto-allocate           Auto per-component placement under a hard VRAM cap\n"
-        "  --auto-fit                Fully automatic: choose DiT quant + placement to fit; ignores --type\n"
+        "  --max-vram <GB>           Compute-graph budget; with --auto-fit on single-device CUDA, also a guarded ceiling\n"
+        "  --auto-allocate           Auto per-component placement under a VRAM planning budget\n"
+        "  --auto-fit                Replan TE/DiT quant + placement; --type still controls VAE precision\n"
         "  --vae-tiling <on|off|auto>  VAE tiled decode (reduces VRAM)\n\n"
         "Timing:\n"
         "  --warmup <int>            Untimed warm-up generations (images still written). Default 1\n"
@@ -544,6 +548,7 @@ int main(int argc, char** argv) {
     ctx_params.offload_params_to_cpu = args.offload_to_cpu;
     ctx_params.dit_offload = args.dit_offload;
     ctx_params.text_encoder_offload = args.text_encoder_offload;
+    ctx_params.minimax_h3_stage_lifecycle = args.minimax_h3_stage_lifecycle;
     ctx_params.auto_allocate = args.auto_allocate;
     ctx_params.auto_fit = args.auto_fit;
     ctx_params.vae_offload = args.vae_offload;
@@ -657,8 +662,8 @@ int main(int argc, char** argv) {
                 vgen.height = args.height;
                 vgen.frames = generation_frames;
                 vgen.seed = seed;
-                vgen.sample.sampler = ED_SAMPLER_AUTO;
-                vgen.sample.scheduler = ED_SCHEDULER_AUTO;
+                vgen.sample.sampler = args.sampler;
+                vgen.sample.scheduler = args.scheduler;
                 vgen.sample.steps = args.steps;
                 vgen.sample.cfg_scale = args.cfg_scale;
                 vgen.sample.image_cfg_scale = 1.0f;
@@ -695,8 +700,8 @@ int main(int argc, char** argv) {
                 gen.height = args.height;
                 gen.seed = seed;
                 gen.batch_count = 1;
-                gen.sample.sampler = ED_SAMPLER_AUTO;
-                gen.sample.scheduler = ED_SCHEDULER_AUTO;
+                gen.sample.sampler = args.sampler;
+                gen.sample.scheduler = args.scheduler;
                 gen.sample.steps = args.steps;
                 gen.sample.cfg_scale = args.cfg_scale;
                 gen.sample.image_cfg_scale = 1.0f;
diff --git a/include/edge-dit.h b/include/edge-dit.h
index d93267f..c00f172 100644
--- a/include/edge-dit.h
+++ b/include/edge-dit.h
@@ -95,6 +95,11 @@ typedef enum ed_scheduler_t {
     ED_SCHEDULER_BONG_TANGENT
 } ed_scheduler_t;
 
+typedef enum ed_ref_image_size_t {
+    ED_REF_IMAGE_SIZE_MAX = 0,
+    ED_REF_IMAGE_SIZE_MATCH = 1,
+} ed_ref_image_size_t;
+
 typedef enum ed_cache_mode_t {
     ED_CACHE_DISABLED = 0,
     ED_CACHE_EASYCACHE,
@@ -182,7 +187,8 @@ typedef struct ed_context_params_t {
     bool offload_params_to_cpu;
     bool dit_offload;           // DiT weights on CPU, staged to GPU per step (compute on GPU)
     bool text_encoder_offload;  // TE weights on CPU, staged to GPU per encode (compute on GPU)
-    bool auto_allocate;         // budget-capped auto placement: min(--max-vram, free) hard cap, per-component resident/offload
+    bool minimax_h3_stage_lifecycle;  // MiniMax-H3: stage TE/VAE by phase, release them during DiT
+    bool auto_allocate;         // budget-capped placement: min(--max-vram, free), per-component resident/offload; external workspaces may raise process peak
     bool auto_fit;              // fully automatic: system picks DiT quantization (q8_0..q4_k) AND placement to fit budget; implies auto_allocate, ignores weight_type
     int fit_width;              // target generation width for auto-allocate/auto-fit compute-buffer measurement (0 = unspecified -> fixed headroom fallback)
     int fit_height;             // target generation height (0 = unspecified)
@@ -276,6 +282,7 @@ typedef struct ed_video_generation_params_t {
 
     const ed_image_t * ref_images;
     int ref_image_count;
+    ed_ref_image_size_t ref_image_size;
     const ed_ref_video_t * ref_videos;
     int ref_video_count;
     const ed_audio_t * ref_audios;
diff --git a/scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py b/scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py
index 570a7bd..7a691c9 100755
--- a/scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py
+++ b/scripts/diffusers/run_minimax_h3_ref2va_quantized_official_video.py
@@ -78,12 +78,14 @@ def main():
     ap=argparse.ArgumentParser()
     ap.add_argument("--model", type=Path, required=True)
     ap.add_argument("--output", type=Path, required=True)
+    ap.add_argument("--metrics", type=Path)
     ap.add_argument("--prompt", required=True)
     ap.add_argument("--seed", type=int, default=42)
     ap.add_argument("--height", type=int, default=480)
     ap.add_argument("--width", type=int, default=864)
     ap.add_argument("--num-frames", type=int, default=124)
     ap.add_argument("--steps", type=int, default=20)
+    ap.add_argument("--fps", type=float, default=24.0)
     ap.add_argument("--bits", type=int, choices=(4,8), default=4)
     ap.add_argument("--device", default="cuda")
     ap.add_argument("--resident", action="store_true")
@@ -100,6 +102,8 @@ def main():
     refs=build_refs(args)
     started=time.perf_counter()
     pipe=ModularPipeline.from_pretrained(args.model, workflow="ref2va", local_files_only=True)
+    if args.fps == 24.0 and args.num_frames == 362:
+        type(pipe).max_duration = property(lambda self: args.num_frames / args.fps)
     initialized=time.perf_counter()
     qconf=make_quant_config(args.bits)
     pipe.update_components(
@@ -130,11 +134,16 @@ def inner(*a, **k):
             return inner
         pipe.vae.encode=wrap("video_vae_encode", pipe.vae.encode); pipe.vae.decode=wrap("video_vae_decode", pipe.vae.decode)
         pipe.audio_vae.encode=wrap("audio_vae_encode", pipe.audio_vae.encode); pipe.audio_vae.decode=wrap("audio_vae_decode", pipe.audio_vae.decode)
+        pipe.text_encoder.model.forward=wrap("text_encoder", pipe.text_encoder.model.forward)
     gen=torch.Generator(device="cpu").manual_seed(args.seed)
     torch.cuda.reset_peak_memory_stats(device); sync_time()
     out=pipe(prompt=args.prompt, references=refs, height=args.height, width=args.width, num_frames=args.num_frames, num_inference_steps=args.steps, generator=gen, output=["videos","audio","sampling_rate"])
     generated_at=sync_time()
-    encode_video(out["videos"][0], fps=24, output_path=str(args.output), audio=out["audio"][0], audio_sample_rate=out["sampling_rate"])
+    encode_video(out["videos"][0], fps=args.fps, output_path=str(args.output), audio=out["audio"][0], audio_sample_rate=out["sampling_rate"])
     finished=time.perf_counter()
-    print(json.dumps({"framework":"diffusers-main","workflow":"ref2va","model":str(args.model),"dtype":"bfloat16","quantization":{"method":"TorchAO weight-only","bits":args.bits,"transformer_quantized":True,"text_encoder_quantized":True,"vae_quantized":False,"audio_vae_quantized":False},"prompt":args.prompt,"references":[{"type":type(r).__name__,"kind":getattr(r,"kind",None),"fps":getattr(r,"fps",None),"frames":(len(getattr(r,"frames",[])) if not hasattr(getattr(r,"frames",None),"shape") else int(getattr(r,"frames").shape[0])) if hasattr(r,"frames") else None,"has_audio":bool(getattr(r,"has_audio",False)),"sample_rate":getattr(r,"sample_rate",None)} for r in refs],"height":args.height,"width":args.width,"requested_num_frames":args.num_frames,"num_inference_steps":args.steps,"seconds":{"pipeline_init":initialized-started,"quantized_component_load":quant_loaded-initialized,"component_finalize":ready-quant_loaded,"generate_cuda":generated_at-ready,"transformer_forward_cuda":transformer_profile["seconds"],"mux":finished-generated_at,"end_to_end":finished-started},"transformer_forward_calls":transformer_profile["calls"],"component_profile":comp,"memory_bytes":{"max_allocated_during_generate":torch.cuda.max_memory_allocated(device),"max_reserved_during_generate":torch.cuda.max_memory_reserved(device)}}, indent=2))
+    metrics={"framework":"diffusers-main","workflow":"ref2va","model":str(args.model),"dtype":"bfloat16","quantization":{"method":"TorchAO weight-only","bits":args.bits,"transformer_quantized":True,"text_encoder_quantized":True,"vae_quantized":False,"audio_vae_quantized":False},"prompt":args.prompt,"references":[{"type":type(r).__name__,"kind":getattr(r,"kind",None),"fps":getattr(r,"fps",None),"frames":(len(getattr(r,"frames",[])) if not hasattr(getattr(r,"frames",None),"shape") else int(getattr(r,"frames").shape[0])) if hasattr(r,"frames") else None,"has_audio":bool(getattr(r,"has_audio",False)),"sample_rate":getattr(r,"sample_rate",None)} for r in refs],"height":args.height,"width":args.width,"requested_num_frames":args.num_frames,"fps":args.fps,"num_inference_steps":args.steps,"seconds":{"pipeline_init":initialized-started,"quantized_component_load":quant_loaded-initialized,"component_finalize":ready-quant_loaded,"generate_cuda":generated_at-ready,"transformer_forward_cuda":transformer_profile["seconds"],"mux":finished-generated_at,"end_to_end":finished-started},"transformer_forward_calls":transformer_profile["calls"],"component_profile":comp,"memory_bytes":{"max_allocated_during_generate":torch.cuda.max_memory_allocated(device),"max_reserved_during_generate":torch.cuda.max_memory_reserved(device)}}
+    if args.metrics:
+        args.metrics.parent.mkdir(parents=True, exist_ok=True)
+        args.metrics.write_text(json.dumps(metrics, indent=2))
+    print(json.dumps(metrics, indent=2))
 if __name__ == "__main__": main()
diff --git a/src/core/backend/cuDNN/ed_cudnn_conv2d.cu b/src/core/backend/cuDNN/ed_cudnn_conv2d.cu
index 0d4c7a5..63c59bc 100644
--- a/src/core/backend/cuDNN/ed_cudnn_conv2d.cu
+++ b/src/core/backend/cuDNN/ed_cudnn_conv2d.cu
@@ -1,6 +1,7 @@
 #include "ed_cudnn_conv2d.h"
 
 #include "common.cuh"
+#include "ggml-cuda.h"
 
 #include <cuda_runtime.h>
 #include <cudnn.h>
@@ -533,7 +534,7 @@ static void * get_workspace(int device, cudaStream_t stream, size_t workspace_si
             workspace->ptr = nullptr;
             workspace->size = 0;
         }
-        if (cudaMalloc(&workspace->ptr, workspace_size) != cudaSuccess) {
+        if (!ggml_backend_cuda_try_malloc(device, &workspace->ptr, workspace_size)) {
             cudaSetDevice(old_device);
             workspace->ptr = nullptr;
             workspace->size = 0;
@@ -573,7 +574,7 @@ static void * get_scratch(int device, cudaStream_t stream, size_t scratch_size)
             scratch->ptr = nullptr;
             scratch->size = 0;
         }
-        if (cudaMalloc(&scratch->ptr, scratch_size) != cudaSuccess) {
+        if (!ggml_backend_cuda_try_malloc(device, &scratch->ptr, scratch_size)) {
             cudaSetDevice(old_device);
             scratch->ptr = nullptr;
             scratch->size = 0;
diff --git a/src/core/backend/cuDNN/ed_cudnn_conv3d.cu b/src/core/backend/cuDNN/ed_cudnn_conv3d.cu
index eb9d0a9..5de429d 100644
--- a/src/core/backend/cuDNN/ed_cudnn_conv3d.cu
+++ b/src/core/backend/cuDNN/ed_cudnn_conv3d.cu
@@ -1,6 +1,7 @@
 #include "ed_cudnn_conv3d.h"
 
 #include "common.cuh"
+#include "ggml-cuda.h"
 
 #include <cuda_bf16.h>
 #include <cuda_runtime.h>
@@ -697,7 +698,7 @@ static void * get_workspace(int device, cudaStream_t stream, size_t workspace_si
             workspace->ptr = nullptr;
             workspace->size = 0;
         }
-        if (cudaMalloc(&workspace->ptr, workspace_size) != cudaSuccess) {
+        if (!ggml_backend_cuda_try_malloc(device, &workspace->ptr, workspace_size)) {
             cudaSetDevice(old_device);
             workspace->ptr = nullptr;
             workspace->size = 0;
@@ -737,7 +738,7 @@ static void * get_scratch(int device, cudaStream_t stream, size_t scratch_size)
             scratch->ptr = nullptr;
             scratch->size = 0;
         }
-        if (cudaMalloc(&scratch->ptr, scratch_size) != cudaSuccess) {
+        if (!ggml_backend_cuda_try_malloc(device, &scratch->ptr, scratch_size)) {
             cudaSetDevice(old_device);
             scratch->ptr = nullptr;
             scratch->size = 0;
@@ -817,6 +818,39 @@ static __global__ void half_to_float2_bias_kernel(const half * __restrict__ src,
     reinterpret_cast<float2 *>(dst)[idx2] = v;
 }
 
+static __global__ void float_bias_inplace_kernel(float * __restrict__ dst,
+                                                 const float * __restrict__ bias,
+                                                 int64_t total,
+                                                 int64_t plane,
+                                                 int64_t oc) {
+    const int64_t idx = (int64_t) blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx < total) {
+        dst[idx] += bias[(idx / plane) % oc];
+    }
+}
+
+static __global__ void half_bias_inplace_kernel(half * __restrict__ dst,
+                                                const float * __restrict__ bias,
+                                                int64_t total,
+                                                int64_t plane,
+                                                int64_t oc) {
+    const int64_t idx = (int64_t) blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx < total) {
+        dst[idx] = __float2half_rn(__half2float(dst[idx]) + bias[(idx / plane) % oc]);
+    }
+}
+
+static __global__ void bf16_bias_inplace_kernel(__nv_bfloat16 * __restrict__ dst,
+                                                const float * __restrict__ bias,
+                                                int64_t total,
+                                                int64_t plane,
+                                                int64_t oc) {
+    const int64_t idx = (int64_t) blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx < total) {
+        dst[idx] = __float2bfloat16_rn(__bfloat162float(dst[idx]) + bias[(idx / plane) % oc]);
+    }
+}
+
 static bool aligned_for_float2_to_half2(const void * src, const void * dst, int64_t n) {
     return (n & 1) == 0 &&
            (reinterpret_cast<uintptr_t>(src) % alignof(float2)) == 0 &&
@@ -877,6 +911,31 @@ static void half_to_float_bias_async(const void * src,
         (const half *) src, (const float *) bias, (float *) dst, ow, oh, od, oc, n);
 }
 
+static void output_bias_inplace_async(void * dst,
+                                      const void * bias,
+                                      ggml_type dst_type,
+                                      int64_t ow,
+                                      int64_t oh,
+                                      int64_t od,
+                                      int64_t oc,
+                                      int64_t n,
+                                      cudaStream_t stream) {
+    constexpr int block_size = 256;
+    const int64_t plane = ow * oh * od;
+    const int64_t total = plane * oc * n;
+    const int64_t grid_size = (total + block_size - 1) / block_size;
+    if (dst_type == GGML_TYPE_F32) {
+        float_bias_inplace_kernel<<<grid_size, block_size, 0, stream>>>(
+            (float *) dst, (const float *) bias, total, plane, oc);
+    } else if (dst_type == GGML_TYPE_F16) {
+        half_bias_inplace_kernel<<<grid_size, block_size, 0, stream>>>(
+            (half *) dst, (const float *) bias, total, plane, oc);
+    } else if (dst_type == GGML_TYPE_BF16) {
+        bf16_bias_inplace_kernel<<<grid_size, block_size, 0, stream>>>(
+            (__nv_bfloat16 *) dst, (const float *) bias, total, plane, oc);
+    }
+}
+
 static double elapsed_ms(cudaEvent_t start, cudaEvent_t stop) {
     float elapsed = 0.0f;
     cudaEventElapsedTime(&elapsed, start, stop);
@@ -1094,6 +1153,24 @@ ed_cudnn_conv3d_result_t ed_cudnn_conv3d_compute(ggml_tensor * dst, ed_cudnn_con
             cudaEventSynchronize(profile_stop);
             finalize_ms = elapsed_ms(profile_start, profile_stop);
         }
+    } else if (dst->src[2] != nullptr) {
+        if (do_profile) {
+            cudaEventRecord(profile_start, stream);
+        }
+        output_bias_inplace_async(dst->data,
+                                  dst->src[2]->data,
+                                  dst->type,
+                                  key.ow,
+                                  key.oh,
+                                  key.od,
+                                  key.oc,
+                                  key.n,
+                                  stream);
+        if (do_profile) {
+            cudaEventRecord(profile_stop, stream);
+            cudaEventSynchronize(profile_stop);
+            finalize_ms = elapsed_ms(profile_start, profile_stop);
+        }
     }
     if (do_profile) {
         profile_record(key, get_plan_ms, workspace_ms, prepare_ms, finalize_ms, execute_ms);
diff --git a/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu b/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
index c23f185..d033502 100644
--- a/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
+++ b/src/core/backend/cuDNN/ed_cudnn_conv_transpose_1d.cu
@@ -1,4 +1,5 @@
 #include "ed_cudnn_conv_transpose_1d.h"
+#include "ggml-cuda.h"
 
 #include <cuda_runtime.h>
 #include <cudnn.h>
@@ -96,7 +97,7 @@ static void * get_workspace(int device, cudaStream_t stream, size_t required) {
         return entry->ptr;
     }
     void * replacement = nullptr;
-    if (cudaMalloc(&replacement, required) != cudaSuccess) {
+    if (!ggml_backend_cuda_try_malloc(device, &replacement, required)) {
         return nullptr;
     }
     cudaFree(entry->ptr);
diff --git a/src/core/backend/cuDNN/ed_cudnn_sdpa.cu b/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
index 0ff7602..ff5aae7 100644
--- a/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
+++ b/src/core/backend/cuDNN/ed_cudnn_sdpa.cu
@@ -1,6 +1,7 @@
 #include "ed_cudnn_sdpa.h"
 
 #include "common.cuh"
+#include "ggml-cuda.h"
 
 #include <cuda_bf16.h>
 #include <cuda_fp16.h>
@@ -675,8 +676,11 @@ static bool should_sync_plan_build(const ed_cudnn_sdpa_key & key) {
     if (key.io_type == GGML_TYPE_BF16 || key.dst_type == GGML_TYPE_F16) {
         return true;
     }
+    const bool long_self_attn = !key.padding_mask &&
+                                key.sq == key.sk &&
+                                key.sq >= 65536;
     return key.dst_type == GGML_TYPE_F32 &&
-           cudnn_sdpa_sync_f32_self_attn_enabled() &&
+           (long_self_attn || cudnn_sdpa_sync_f32_self_attn_enabled()) &&
            !key.padding_mask &&
            key.sq == key.sk &&
            key.sq >= MIN_CUDNN_SDPA_FAST_SEQ;
@@ -763,19 +767,34 @@ static std::unique_ptr<ed_cudnn_sdpa_plan> create_plan(const ed_cudnn_sdpa_key &
         result = ED_CUDNN_SDPA_BUILD_FAILED;
         return nullptr;
     }
-    if (plan->workspace_size > 0) {
-        CUDA_CHECK(cudaMalloc(&plan->workspace, (size_t) plan->workspace_size));
+    auto allocate = [&](void ** ptr, size_t bytes) {
+        if (bytes == 0) {
+            return true;
+        }
+        if (!ggml_backend_cuda_try_malloc(key.device, ptr, bytes)) {
+            result = ED_CUDNN_SDPA_BUILD_FAILED;
+            return false;
+        }
+        return true;
+    };
+    if (!allocate(&plan->workspace, (size_t) plan->workspace_size)) {
+        return nullptr;
     }
     plan->elements = key.b * key.h * key.sq * key.d;
-    CUDA_CHECK(cudaMalloc(&plan->q_io, (size_t) plan->elements * type_size(key.io_type)));
-    if (key.dst_type != key.io_type) {
-        CUDA_CHECK(cudaMalloc(&plan->o_io, (size_t) plan->elements * type_size(key.io_type)));
+    if (!allocate(&plan->q_io, (size_t) plan->elements * type_size(key.io_type))) {
+        return nullptr;
+    }
+    if (key.dst_type != key.io_type &&
+        !allocate(&plan->o_io, (size_t) plan->elements * type_size(key.io_type))) {
+        return nullptr;
     }
     if (key.padding_mask) {
         const int32_t seq_q = (int32_t) key.sq;
         const int32_t seq_kv = (int32_t) key.sk_actual;
-        CUDA_CHECK(cudaMalloc(&plan->seq_len_q, sizeof(int32_t)));
-        CUDA_CHECK(cudaMalloc(&plan->seq_len_kv, sizeof(int32_t)));
+        if (!allocate(reinterpret_cast<void **>(&plan->seq_len_q), sizeof(int32_t)) ||
+            !allocate(reinterpret_cast<void **>(&plan->seq_len_kv), sizeof(int32_t))) {
+            return nullptr;
+        }
         CUDA_CHECK(cudaMemcpy(plan->seq_len_q, &seq_q, sizeof(int32_t), cudaMemcpyHostToDevice));
         CUDA_CHECK(cudaMemcpy(plan->seq_len_kv, &seq_kv, sizeof(int32_t), cudaMemcpyHostToDevice));
     }
diff --git a/src/core/backend/ggml/ggml_extend.hpp b/src/core/backend/ggml/ggml_extend.hpp
index dc115a9..37eae99 100644
--- a/src/core/backend/ggml/ggml_extend.hpp
+++ b/src/core/backend/ggml/ggml_extend.hpp
@@ -2218,6 +2218,7 @@ struct GGMLRunnerContext {
     // means "unknown" -> sage applies to all layers (stage-1 behavior).
     int sage_layer_idx    = -1;
     int sage_total_layers = -1;
+    size_t max_graph_vram_bytes = 0;
 };
 
 // Model-facing tap primitive. Called by a model's forward() at a structural
@@ -2672,6 +2673,7 @@ struct GGMLRunner {
     ggml_context* offload_ctx                   = nullptr;
     ggml_backend_buffer_t runtime_params_buffer = nullptr;
     bool params_on_runtime_backend              = false;
+    bool phase_params_pinned_                   = false;
 
     ggml_context* cache_ctx            = nullptr;
     ggml_backend_buffer_t cache_buffer = nullptr;
@@ -6374,10 +6376,12 @@ struct GGMLRunner {
         // params_already_resident: the segment loop (double-buffer prefetch) has
         // already swapped this segment's weights onto the GPU, so skip the internal
         // offload/restore entirely. Default false keeps every other caller identical.
-        const bool use_partial_param_offload = !runtime_param_tensors.empty() && !params_already_resident;
+        const bool weights_already_resident = params_already_resident || params_on_runtime_backend;
+        const bool use_partial_param_offload = !runtime_param_tensors.empty() && !weights_already_resident;
         int64_t t_offload_begin              = ggml_time_ms();
-        if (params_already_resident) {
-            // weights pre-swapped by caller; nothing to offload here
+        if (weights_already_resident) {
+            // Weights were pre-swapped by the async segment caller or pinned for the
+            // current component phase; do not stage the same tensors a second time.
         } else if (use_partial_param_offload) {
             if (!offload_partial_params(runtime_param_tensors)) {
                 LOG_ERROR("%s offload partial params to runtime backend failed", get_desc().c_str());
@@ -6582,8 +6586,10 @@ struct GGMLRunner {
         // P0-A Phase 2-3: async double-buffered weight prefetch across segments.
         // Only engages when offloading (params on CPU) and ED_ASYNC_OFFLOAD >= 1.
         const int async_lvl = async_offload_level();
-        const bool async_prefetch_on =
-            async_lvl >= 1 && params_backend != runtime_backend && plan.segments.size() > 1;
+        const bool async_prefetch_on = async_lvl >= 1 &&
+                                       params_backend != runtime_backend &&
+                                       !params_on_runtime_backend &&
+                                       plan.segments.size() > 1;
         std::vector<std::vector<ggml_tensor*>> async_seg_params;
         if (async_prefetch_on) {
             // Precompute every segment's param list + a STABLE cpu-source map
@@ -6870,6 +6876,27 @@ struct GGMLRunner {
 public:
     virtual std::string get_desc() = 0;
 
+    bool stage_params_for_phase() {
+        if (params_backend == runtime_backend) {
+            return true;
+        }
+        phase_params_pinned_ = true;
+        if (offload_all_params()) {
+            return true;
+        }
+        phase_params_pinned_ = false;
+        return false;
+    }
+
+    void release_params_after_phase() {
+        if (!phase_params_pinned_) {
+            return;
+        }
+        phase_params_pinned_ = false;
+        invalidate_persistent_graph();
+        restore_all_params();
+    }
+
     // On Apple Silicon the Metal GPU and the CPU share the same physical RAM
     // (unified memory). "Offloading" weights between a CPU backend and the Metal
     // backend therefore copies bytes that already live in the very same physical
@@ -6940,6 +6967,7 @@ struct GGMLRunner {
     }
 
     virtual ~GGMLRunner() {
+        release_params_after_phase();
         free_runtime_const_cache();
         free_params_buffer();
         free_compute_buffer();
@@ -6963,6 +6991,7 @@ struct GGMLRunner {
         runner_ctx.circular_y_enabled    = circular_y_enabled;
         runner_ctx.weight_adapter        = weight_adapter;
         runner_ctx.tap_registry          = tap_registry_;
+        runner_ctx.max_graph_vram_bytes  = max_graph_vram_bytes;
         return runner_ctx;
     }
 
@@ -7081,7 +7110,9 @@ struct GGMLRunner {
         // the next compute_reuse() rebuilds instead of re-executing dangling nodes.
         invalidate_persistent_graph();
         restore_partial_params();
-        restore_all_params();
+        if (!phase_params_pinned_) {
+            restore_all_params();
+        }
     }
 
     // do copy after alloc graph
@@ -8024,15 +8055,20 @@ class Conv3d : public UnaryBlock {
         return w;
     }
 
+    ggml_tensor* bias_for_forward(GGMLRunnerContext* ctx) {
+        if (!bias) {
+            return nullptr;
+        }
+        ggml_tensor* b = params["bias"];
+        if (ctx->weight_adapter) {
+            b = ctx->weight_adapter->patch_weight(ctx->ggml_ctx, ctx->backend, b, prefix + "bias");
+        }
+        return b;
+    }
+
     ggml_tensor* forward(GGMLRunnerContext* ctx, ggml_tensor* x) {
         ggml_tensor* w = weight_for_forward(ctx, false);
-        ggml_tensor* b = nullptr;
-        if (bias) {
-            b = params["bias"];
-            if (ctx->weight_adapter) {
-                b = ctx->weight_adapter->patch_weight(ctx->ggml_ctx, ctx->backend, b, prefix + "bias");
-            }
-        }
+        ggml_tensor* b = bias_for_forward(ctx);
         const bool direct_compatible = ctx->conv3d_auto_direct_enabled &&
                                        x != nullptr &&
                                        w != nullptr &&
diff --git a/src/core/runtime/edge_dit_engine.cpp b/src/core/runtime/edge_dit_engine.cpp
index daefccc..e56c9c9 100644
--- a/src/core/runtime/edge_dit_engine.cpp
+++ b/src/core/runtime/edge_dit_engine.cpp
@@ -199,7 +199,7 @@ bool EdgeDitEngine::init(const ed_ctx_params_t* params) {
 
     PipelineTensorRegistry registry;
     // Auto-fit: before offload planning, let the runtime choose the DiT quant level
-    // (q8_0..q4_k, ignoring --type) that keeps it resident within the VRAM budget (no-op
+    // (q8_0..q4_k, superseding --type for the DiT) that keeps it resident within the VRAM budget (no-op
     // unless --auto-fit). Must run after apply_dtype_policy (expected_type is set) and
     // before prepare (which reads expected_type for offload decisions) and bind_weights
     // (which materializes the quantized weights). Uses the non-const loader.
diff --git a/src/core/runtime/model_loader.cpp b/src/core/runtime/model_loader.cpp
index b430b23..b59761c 100644
--- a/src/core/runtime/model_loader.cpp
+++ b/src/core/runtime/model_loader.cpp
@@ -1703,7 +1703,9 @@ void ModelLoader::set_wtype_override(ggml_type wtype, std::string tensor_type_ru
              tensor_storage_map_.size());
 }
 
-size_t ModelLoader::override_component_wtype(const std::string& prefix, ggml_type dst_type) {
+size_t ModelLoader::override_component_wtype(const std::string& prefix,
+                                             ggml_type dst_type,
+                                             bool allow_precision_increase) {
     if (dst_type == GGML_TYPE_COUNT) {
         return 0;
     }
@@ -1712,6 +1714,16 @@ size_t ModelLoader::override_component_wtype(const std::string& prefix, ggml_typ
         if (item.first.rfind(prefix, 0) != 0) {
             continue;  // not in this component
         }
+        const ggml_type current_type = item.second.expected_type != GGML_TYPE_COUNT
+                                           ? item.second.expected_type
+                                           : item.second.type;
+        if (!allow_precision_increase && ggml_is_quantized(current_type)) {
+            const double current_bpw = 8.0 * ggml_type_size(current_type) / ggml_blck_size(current_type);
+            const double target_bpw  = 8.0 * ggml_type_size(dst_type) / ggml_blck_size(dst_type);
+            if (target_bpw >= current_bpw) {
+                continue;
+            }
+        }
         if (!tensor_should_be_converted(item.second, dst_type)) {
             continue;  // biases/norms/embeds etc. stay as-is (mirrors set_wtype_override)
         }
diff --git a/src/core/runtime/model_loader.h b/src/core/runtime/model_loader.h
index 66eee7f..e6f7b40 100644
--- a/src/core/runtime/model_loader.h
+++ b/src/core/runtime/model_loader.h
@@ -259,11 +259,12 @@ class ModelLoader final {
                             std::string tensor_type_rules = "");
 
     // Budget-aware re-quantization (auto-fit scheduler). Force every tensor whose
-    // name starts with `prefix` (e.g. "model.diffusion_model") to `dst_type`,
-    // overwriting expected_type. Returns the number of tensors changed. Used before
-    // bind_weights to trade a lower DiT quant level for GPU residency. Only lowers
-    // precision in practice; caller enforces the quality floor.
-    size_t override_component_wtype(const std::string& prefix, ggml_type dst_type);
+    // name starts with `prefix` (e.g. "model.diffusion_model") toward `dst_type`.
+    // Existing tensors below the target precision remain unchanged unless
+    // allow_precision_increase is set. Returns the number of tensors changed.
+    size_t override_component_wtype(const std::string& prefix,
+                                    ggml_type dst_type,
+                                    bool allow_precision_increase = false);
 
     bool tensor_should_be_converted(const TensorStorage& tensor_storage,
                                     ggml_type type) const;
diff --git a/src/core/runtime/model_runtime.cpp b/src/core/runtime/model_runtime.cpp
index 535712c..a696364 100644
--- a/src/core/runtime/model_runtime.cpp
+++ b/src/core/runtime/model_runtime.cpp
@@ -12,6 +12,9 @@
 #include "utils/rng_philox.hpp"
 #include "utils/util.h"
 #include "runtime/model_loader.h"
+#if defined(GGML_USE_CUDA)
+#include "ggml-cuda.h"
+#endif
 
 namespace edgedit {
 namespace {
@@ -233,6 +236,7 @@ bool ModelRuntime::init_flags(const ed_context_params_t& params, std::string* er
     use_mmap_ = params.use_mmap;
     offload_params_to_cpu_ = params.offload_params_to_cpu;
     text_encoder_offload_ = params.text_encoder_offload;
+    minimax_h3_stage_lifecycle_ = params.minimax_h3_stage_lifecycle;
     dit_offload_ = params.dit_offload;
     vae_offload_ = params.vae_offload;
     auto_fit_ = params.auto_fit;
@@ -282,6 +286,27 @@ bool ModelRuntime::init_backends(const ed_context_params_t& params, std::string*
     }
     LOG_INFO("default backend: %s", ggml_backend_name(backends_.backend));
 
+#if defined(GGML_USE_CUDA)
+    if (ggml_backend_is_cuda(backends_.backend)) {
+        size_t cuda_allocation_budget = 0;
+        if (auto_fit_ && max_graph_vram_bytes_ > 0) {
+            constexpr size_t external_workspace_reserve = static_cast<size_t>(1) * 1024 * 1024 * 1024;
+            if (max_graph_vram_bytes_ <= external_workspace_reserve) {
+                return fail(error, "--auto-fit --max-vram must exceed the 1 GiB CUDA workspace reserve");
+            }
+            cuda_allocation_budget = max_graph_vram_bytes_ - external_workspace_reserve;
+        }
+        if (!ggml_backend_cuda_set_memory_budget(backends_.backend, cuda_allocation_budget)) {
+            return fail(error, "failed to configure CUDA memory budget");
+        }
+        if (cuda_allocation_budget > 0) {
+            LOG_INFO("auto-fit: CUDA allocation guard = %.2f GiB (%.2f GiB requested, 1.00 GiB reserved for external workspaces)",
+                     cuda_allocation_budget / (1024.0 * 1024.0 * 1024.0),
+                     max_graph_vram_bytes_ / (1024.0 * 1024.0 * 1024.0));
+        }
+    }
+#endif
+
     // Text encoder and VAE no longer run on a dedicated CPU backend. When their
     // offload flags are set they keep weights on CPU but stage to the GPU per
     // encode/decode (compute on GPU), handled by the GGMLRunner offload path via
@@ -512,29 +537,36 @@ void ModelRuntime::replan_dit_quant_for_budget(::ModelLoader& loader) {
     // auto-fit also OWNS the text-encoder quantization. TE (CLIP+T5) is often bf16 and
     // large (~9 GB for flux's T5), but its compute time is negligible vs the DiT, so
     // quantizing it to q8_0 is near-lossless in quality, costs no speed, and halves its
-    // footprint. Forcing TE -> q8_0 frees budget so the DiT can stay resident without the
-    // DiT+TE bf16 pair overflowing VRAM (the 24G OOM cause). Unconditional: q8_0 TE has no
-    // downside here. tensor_should_be_converted already protects embeddings/projections.
+    // footprint. Lowering TE to q8_0 frees budget so the DiT can stay resident without the
+    // DiT+TE bf16 pair overflowing VRAM (the 24G OOM cause). A source already below q8_0
+    // stays at its existing precision; tensor_should_be_converted also protects embeddings/projections.
     const size_t te_before = component_effective_bytes(loader, kTE);
     if (te_before > 0) {
         loader.override_component_wtype(kTE, GGML_TYPE_Q8_0);
         const size_t te_after = component_effective_bytes(loader, kTE);
         if (te_after != te_before) {
-            LOG_INFO("auto-fit: TE quant set to q8_0 (ignoring --type), %.2f GB -> %.2f GB",
+            LOG_INFO("auto-fit: TE quant set to q8_0 (superseding global --type for TE), %.2f GB -> %.2f GB",
                      te_before / (1024.0 * 1024.0 * 1024.0),
                      te_after / (1024.0 * 1024.0 * 1024.0));
         }
     }
 
-    // auto-fit OWNS the DiT quantization: it ignores the user's --type and drives the DiT
-    // through the ladder q8_0 -> q4_k, picking the highest level that stays resident. On a
-    // 4090 q8_0 is the best starting point (bf16 is both larger and slower due to the
-    // FP32-accumulate penalty), so we never consider bf16.
+    // auto-fit owns the DiT decision after the global --type policy is applied. It lowers
+    // eligible high-precision tensors toward q8_0 -> q4_k, but never increases an existing
+    // lower-precision tensor. On a 4090 q8_0 is the best high-quality starting point (bf16
+    // is both larger and slower due to the FP32-accumulate penalty), so we do not retain
+    // bf16 merely to satisfy the automatic budget.
     const size_t bytes_before = component_effective_bytes(loader, kDiT);
     loader.override_component_wtype(kDiT, GGML_TYPE_Q8_0);
     const size_t q8_bytes = component_effective_bytes(loader, kDiT);
+    std::vector<std::pair<std::string, ggml_type>> q8_precision_state;
+    for (const auto& item : loader.get_tensor_storage_map()) {
+        if (item.first.rfind(kDiT, 0) == 0) {
+            q8_precision_state.emplace_back(item.first, item.second.expected_type);
+        }
+    }
     if (q8_bytes != bytes_before) {
-        LOG_INFO("auto-fit: DiT quant set to q8_0 (ignoring --type), %.2f GB",
+        LOG_INFO("auto-fit: DiT quant set to q8_0 (superseding global --type for DiT), %.2f GB",
                  q8_bytes / (1024.0 * 1024.0 * 1024.0));
     }
 
@@ -551,30 +583,39 @@ void ModelRuntime::replan_dit_quant_for_budget(::ModelLoader& loader) {
     const size_t dit_budget = budget - headroom;
 
     if (q8_bytes <= dit_budget) {
-        LOG_INFO("auto-fit: DiT q8_0 %.2f GB fits %.2f GB budget -> resident",
+        LOG_INFO("auto-fit: DiT source-or-Q8 precision %.2f GB fits %.2f GB budget -> resident",
                  q8_bytes / (1024.0 * 1024.0 * 1024.0),
                  dit_budget / (1024.0 * 1024.0 * 1024.0));
         return;  // q8_0 already fits -> keep it (highest precision in the ladder)
     }
 
-    // q8_0 does not fit -> try q4_k (the floor). Keep it if it fits; else leave at q8_0
-    // and let plan_component_offload offload the DiT.
+    // The source-or-Q8 candidate does not fit -> try q4_k (the floor). Keep it if it fits;
+    // otherwise restore the candidate precision and let plan_component_offload offload it.
     loader.override_component_wtype(kDiT, GGML_TYPE_Q4_K);
     const size_t q4_bytes = component_effective_bytes(loader, kDiT);
     if (q4_bytes <= dit_budget) {
-        LOG_INFO("auto-fit: DiT q8_0 %.2f GB -> q4_K %.2f GB to fit %.2f GB budget (resident)",
+        LOG_INFO("auto-fit: DiT source-or-Q8 %.2f GB -> q4_K %.2f GB to fit %.2f GB budget (resident)",
                  q8_bytes / (1024.0 * 1024.0 * 1024.0),
                  q4_bytes / (1024.0 * 1024.0 * 1024.0),
                  dit_budget / (1024.0 * 1024.0 * 1024.0));
         return;
     }
 
-    // Even q4_k does not fit: revert to q8_0 (offloaded is better quality than a q4 that
-    // still has to offload anyway).
-    loader.override_component_wtype(kDiT, GGML_TYPE_Q8_0);
-    LOG_INFO("auto-fit: DiT does not fit %.2f GB budget even at q4_K (q4=%.2f GB) -> q8_0, will offload",
-             dit_budget / (1024.0 * 1024.0 * 1024.0),
-             q4_bytes / (1024.0 * 1024.0 * 1024.0));
+    // Even q4_k does not fit: restore the post-Q8 planning state. This keeps BF16/F16
+    // sources at Q8 while preserving any user-supplied Q5/Q6/Q4-or-lower tensors instead
+    // of accidentally increasing their precision during the fallback.
+    if (q8_bytes != q4_bytes) {
+        auto& storage_map = loader.get_tensor_storage_map();
+        for (const auto& state : q8_precision_state) {
+            storage_map.at(state.first).expected_type = state.second;
+        }
+        LOG_INFO("auto-fit: DiT does not fit %.2f GB budget even at q4_K (q4=%.2f GB) -> restore source-or-Q8 precision, will offload",
+                 dit_budget / (1024.0 * 1024.0 * 1024.0),
+                 q4_bytes / (1024.0 * 1024.0 * 1024.0));
+    } else {
+        LOG_INFO("auto-fit: source DiT is already q4_K or lower and does not fit %.2f GB budget -> preserve source precision and offload",
+                 dit_budget / (1024.0 * 1024.0 * 1024.0));
+    }
 }
 
 size_t ModelRuntime::effective_budget_bytes() const {
@@ -698,6 +739,7 @@ void ModelRuntime::reset() {
     use_mmap_ = false;
     offload_params_to_cpu_ = false;
     text_encoder_offload_ = false;
+    minimax_h3_stage_lifecycle_ = false;
     dit_offload_ = false;
     vae_offload_ = false;
     free_params_immediately_ = false;
diff --git a/src/core/runtime/model_runtime.hpp b/src/core/runtime/model_runtime.hpp
index 94b79d3..1cca758 100644
--- a/src/core/runtime/model_runtime.hpp
+++ b/src/core/runtime/model_runtime.hpp
@@ -128,6 +128,7 @@ class ModelRuntime final {
     // Text encoder should offload (weights on CPU, staged to GPU per encode) when
     // either the global offload flag or the TE-specific flag is set.
     bool clip_offload_params_to_cpu() const { return offload_params_to_cpu_ || text_encoder_offload_; }
+    bool minimax_h3_stage_lifecycle() const { return minimax_h3_stage_lifecycle_; }
     // DiT should offload (weights on CPU, staged to GPU per step) when either the
     // global offload flag or the DiT-specific flag is set.
     bool dit_offload_params_to_cpu() const { return offload_params_to_cpu_ || dit_offload_; }
@@ -227,6 +228,7 @@ class ModelRuntime final {
     bool use_mmap_ = false;
     bool offload_params_to_cpu_ = false;
     bool text_encoder_offload_ = false;
+    bool minimax_h3_stage_lifecycle_ = false;
     bool dit_offload_ = false;
     bool vae_offload_ = false;
     bool auto_allocate_ = false;
diff --git a/src/dit_models/components/text_encoders/llm.hpp b/src/dit_models/components/text_encoders/llm.hpp
index 95ec09b..992d7b8 100644
--- a/src/dit_models/components/text_encoders/llm.hpp
+++ b/src/dit_models/components/text_encoders/llm.hpp
@@ -447,6 +447,7 @@ namespace LLM {
                 auto proj = std::dynamic_pointer_cast<Conv3d>(blocks["proj"]);
 
                 ggml_tensor* w = proj->weight_for_forward(ctx, true);
+                ggml_tensor* b = proj->bias_for_forward(ctx);
                 if ((w->type == GGML_TYPE_F16 || w->type == GGML_TYPE_BF16) && x->type != w->type) {
                     x = ggml_cast(ctx->ggml_ctx, x, w->type);
                 }
@@ -467,7 +468,7 @@ namespace LLM {
                     ggml_tensor* y_conv = ggml_ext_conv_3d_direct_typed(ctx->ggml_ctx,
                                                                         x_conv,
                                                                         w,
-                                                                        nullptr,
+                                                                        b,
                                                                         in_channels,
                                                                         patch_count,
                                                                         embed_dim,
@@ -490,7 +491,7 @@ namespace LLM {
                                     w,
                                     patch_dim,
                                     embed_dim);
-                x = ggml_ext_linear(ctx->ggml_ctx, x, w, nullptr);
+                x = ggml_ext_linear(ctx->ggml_ctx, x, w, b);
                 if (qwen_align_diffusers_vision_dtype_enabled() &&
                     (w->type == GGML_TYPE_F16 || w->type == GGML_TYPE_BF16) &&
                     x->type != w->type) {
@@ -674,7 +675,7 @@ namespace LLM {
             head_dim = static_cast<int>(hidden_size / num_heads);
             GGML_ASSERT(num_heads * head_dim == hidden_size);
             const bool diffusers_dtype = arch_ == LLMVisionArch::QWEN2_5_VL && qwen_align_diffusers_vision_dtype_enabled();
-            const bool bias = arch_ == LLMVisionArch::QWEN2_5_VL;
+            const bool bias = arch_ == LLMVisionArch::QWEN2_5_VL || arch_ == LLMVisionArch::QWEN3_VL;
             if (llama_cpp_style) {
                 blocks["q_proj"] = std::shared_ptr<GGMLBlock>(new Linear(hidden_size,
                                                                          hidden_size,
@@ -1303,7 +1304,6 @@ namespace LLM {
             k = ggml_cont(ctx->ggml_ctx, ggml_ext_torch_permute(ctx->ggml_ctx, k, 0, 2, 1, 3));  // [N, num_kv_heads, n_token, head_dim]
             k = ggml_reshape_3d(ctx->ggml_ctx, k, k->ne[0], k->ne[1], k->ne[2] * k->ne[3]);      // [N*num_kv_heads, n_token, head_dim]
 
-            const bool use_masked_flash_attention = arch == LLMArch::QWEN3_VL && n_token >= 2048;
             x = ggml_ext_attention_ext(ctx->ggml_ctx,
                                        ctx->backend,
                                        q,
@@ -1312,13 +1312,13 @@ namespace LLM {
                                        num_heads,
                                        attention_mask,
                                        true,
-                                       use_masked_flash_attention,
+                                       false,
                                        1.0f,
                                        true,
                                        false,
                                        -1,
                                        -1,
-                                       use_masked_flash_attention);  // [N, n_token, hidden_size]
+                                       false);  // [N, n_token, hidden_size]
             if (diffusers_dtype &&
                 (attention_output_type == GGML_TYPE_F16 || attention_output_type == GGML_TYPE_BF16) &&
                 x->type != attention_output_type) {
diff --git a/src/dit_models/components/text_encoders/tokenizers/tokenize_util.cpp b/src/dit_models/components/text_encoders/tokenizers/tokenize_util.cpp
index 770bfb5..cb2e64c 100644
--- a/src/dit_models/components/text_encoders/tokenizers/tokenize_util.cpp
+++ b/src/dit_models/components/text_encoders/tokenizers/tokenize_util.cpp
@@ -877,12 +877,12 @@ std::vector<std::string> token_split(const std::string& text) {
         // ` ?[^\s\p{L}\p{N}]+[\r\n]*`
         {
             // ` [^\s\p{L}\p{N}]+[\r\n]*`
-            if (cp == U' ' && i + 1 < cps.size() && !isspace(cps[i + 1]) && !is_letter(cps[i + 1]) && !is_number(cps[i + 1])) {
+            if (cp == U' ' && i + 1 < cps.size() && !is_space(cps[i + 1]) && !is_letter(cps[i + 1]) && !is_number(cps[i + 1])) {
                 std::string token = codepoint_to_utf8(cp);
                 token += codepoint_to_utf8(cps[i + 1]);
                 i += 2;
 
-                while (i < cps.size() && !is_letter(cps[i]) && !is_number(cps[i]) && !isspace(cps[i])) {
+                while (i < cps.size() && !is_letter(cps[i]) && !is_number(cps[i]) && !is_space(cps[i])) {
                     token += codepoint_to_utf8(cps[i]);
                     ++i;
                 }
@@ -898,11 +898,11 @@ std::vector<std::string> token_split(const std::string& text) {
 
             // `[^\s\p{L}\p{N}]+[\r\n]*`
             std::string token;
-            if (!is_letter(cps[i]) && !is_number(cps[i]) && !isspace(cps[i])) {
-                std::string token = codepoint_to_utf8(cp);
+            if (!is_letter(cps[i]) && !is_number(cps[i]) && !is_space(cps[i])) {
+                token = codepoint_to_utf8(cp);
                 ++i;
 
-                while (i < cps.size() && !is_letter(cps[i]) && !is_number(cps[i]) && !isspace(cps[i])) {
+                while (i < cps.size() && !is_letter(cps[i]) && !is_number(cps[i]) && !is_space(cps[i])) {
                     token += codepoint_to_utf8(cps[i]);
                     ++i;
                 }
diff --git a/src/dit_models/models/minimax_h3_full.hpp b/src/dit_models/models/minimax_h3_full.hpp
index 8684d8f..276d7a5 100644
--- a/src/dit_models/models/minimax_h3_full.hpp
+++ b/src/dit_models/models/minimax_h3_full.hpp
@@ -177,8 +177,13 @@ namespace MiniMaxH3 {
     };
 
     struct MLP : public UnaryBlock {
+        int64_t hidden_size;
+        int64_t ffn_hidden_size;
+
         MLP(int64_t hidden_size,
-            int64_t ffn_hidden_size) {
+            int64_t ffn_hidden_size)
+            : hidden_size(hidden_size),
+              ffn_hidden_size(ffn_hidden_size) {
             blocks["fc1"] = std::make_shared<Linear>(hidden_size,
                                                       ffn_hidden_size * 2,
                                                       false,
@@ -209,13 +214,45 @@ namespace MiniMaxH3 {
             const bool use_fc2_tensor_cores = use_mlp_tensor_cores || h3_env_flag_enabled("ED_MINIMAX_H3_FC2_FP16_CUBLAS");
             fc1->set_force_prec_f32(!use_fc1_tensor_cores);
             fc2->set_force_prec_f32(!use_fc2_tensor_cores);
-            if (h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_SWIGLU_FUSION")) {
-                auto uv = ggml_ext_chunk(ctx->ggml_ctx, fc1->forward(ctx, x), 2, 0);
-                return fc2->forward(ctx, ggml_mul(ctx->ggml_ctx,
-                                                  ggml_silu(ctx->ggml_ctx, uv[0]),
-                                                  uv[1]));
+            auto forward_chunk = [&](ggml_tensor* chunk) {
+                auto fc1_output = fc1->forward(ctx, chunk);
+                if (h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_SWIGLU_FUSION")) {
+                    auto uv = ggml_ext_chunk(ctx->ggml_ctx, fc1_output, 2, 0);
+                    return fc2->forward(ctx, ggml_mul(ctx->ggml_ctx,
+                                                      ggml_silu(ctx->ggml_ctx, uv[0]),
+                                                      uv[1]));
+                }
+                return fc2->forward(ctx, ggml_swiglu(ctx->ggml_ctx, fc1_output));
+            };
+
+            const int64_t sequence = x->ne[1];
+            if (ctx->max_graph_vram_bytes == 0 || sequence <= 32768) {
+                return forward_chunk(x);
+            }
+
+            constexpr size_t min_working_bytes = static_cast<size_t>(512) * 1024 * 1024;
+            const size_t persistent_bytes = ggml_nbytes(x) * 2 + min_working_bytes;
+            const size_t working_bytes = ctx->max_graph_vram_bytes > persistent_bytes
+                                             ? ctx->max_graph_vram_bytes - persistent_bytes
+                                             : min_working_bytes;
+            const size_t bytes_per_token = static_cast<size_t>(3 * ffn_hidden_size + hidden_size) * sizeof(float);
+            int64_t chunk_tokens = static_cast<int64_t>(working_bytes / std::max<size_t>(bytes_per_token, 1));
+            const int64_t max_chunk_tokens = ctx->max_graph_vram_bytes <= static_cast<size_t>(20) * 1024 * 1024 * 1024
+                                                 ? 8192
+                                                 : 32768;
+            chunk_tokens = std::clamp<int64_t>((chunk_tokens / 256) * 256, 2048, max_chunk_tokens);
+            if (chunk_tokens >= sequence) {
+                return forward_chunk(x);
             }
-            return fc2->forward(ctx, ggml_swiglu(ctx->ggml_ctx, fc1->forward(ctx, x)));
+
+            ggml_tensor* output = nullptr;
+            for (int64_t start = 0; start < sequence; start += chunk_tokens) {
+                const int64_t end = std::min(sequence, start + chunk_tokens);
+                auto chunk = ggml_ext_slice(ctx->ggml_ctx, x, 1, start, end, true);
+                auto chunk_output = forward_chunk(chunk);
+                output = output == nullptr ? chunk_output : ggml_concat(ctx->ggml_ctx, output, chunk_output, 1);
+            }
+            return output;
         }
     };
 
@@ -303,15 +340,32 @@ namespace MiniMaxH3 {
 
             int64_t sequence = x->ne[1];
             int64_t batch    = x->ne[2] * x->ne[3];
-            auto qkv_out     = qkv_proj->forward(ctx, x);
+            const int64_t inner = heads * head_dim;
+            const size_t attention_activation_bytes =
+                static_cast<size_t>(sequence) * static_cast<size_t>(batch) *
+                    static_cast<size_t>(3 * x->ne[0] + 6 * inner) * sizeof(float) +
+                static_cast<size_t>(1) * 1024 * 1024 * 1024;
+            const bool low_memory_attention = ctx->max_graph_vram_bytes > 0 &&
+                                              sequence > 32768 &&
+                                              attention_activation_bytes > ctx->max_graph_vram_bytes;
             std::vector<ggml_tensor*> qkv;
-            if (h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_QKV_VIEW")) {
-                qkv = ggml_ext_chunk(ctx->ggml_ctx, qkv_out, 3, 0);
-                qkv[0] = ggml_reshape_4d(ctx->ggml_ctx, qkv[0], head_dim, heads, sequence, batch);
-                qkv[1] = ggml_reshape_4d(ctx->ggml_ctx, qkv[1], head_dim, heads, sequence, batch);
-                qkv[2] = ggml_reshape_4d(ctx->ggml_ctx, qkv[2], head_dim, heads, sequence, batch);
+            if (low_memory_attention) {
+                qkv.reserve(3);
+                for (int projection = 0; projection < 3; ++projection) {
+                    auto projected = qkv_proj->forward_output_slice(ctx, x, projection * inner, inner);
+                    projected = ggml_reshape_4d(ctx->ggml_ctx, projected, head_dim, heads, sequence, batch);
+                    qkv.push_back(projected);
+                }
             } else {
-                qkv = h3_qkv_views(ctx->ggml_ctx, qkv_out, head_dim, heads, sequence, batch);
+                auto qkv_out = qkv_proj->forward(ctx, x);
+                if (h3_env_flag_enabled("ED_MINIMAX_H3_DISABLE_QKV_VIEW")) {
+                    qkv = ggml_ext_chunk(ctx->ggml_ctx, qkv_out, 3, 0);
+                    qkv[0] = ggml_reshape_4d(ctx->ggml_ctx, qkv[0], head_dim, heads, sequence, batch);
+                    qkv[1] = ggml_reshape_4d(ctx->ggml_ctx, qkv[1], head_dim, heads, sequence, batch);
+                    qkv[2] = ggml_reshape_4d(ctx->ggml_ctx, qkv[2], head_dim, heads, sequence, batch);
+                } else {
+                    qkv = h3_qkv_views(ctx->ggml_ctx, qkv_out, head_dim, heads, sequence, batch);
+                }
             }
             auto q           = qkv[0];
             auto k           = qkv[1];
@@ -325,6 +379,11 @@ namespace MiniMaxH3 {
                 q = attention_layout(ctx->ggml_ctx, q);
                 k = attention_layout(ctx->ggml_ctx, k);
             }
+            if (low_memory_attention) {
+                q = ggml_cast(ctx->ggml_ctx, q, GGML_TYPE_BF16);
+                k = ggml_cast(ctx->ggml_ctx, k, GGML_TYPE_BF16);
+                v = ggml_cast(ctx->ggml_ctx, v, GGML_TYPE_BF16);
+            }
             auto out = ggml_ext_attention_ext(ctx->ggml_ctx,
                                               ctx->backend,
                                               q,
@@ -334,7 +393,8 @@ namespace MiniMaxH3 {
                                               nullptr,
                                               true,
                                               ctx->flash_attn_enabled,
-                                              1.f / 128.f);
+                                              1.f / 128.f,
+                                              sequence < 65536);
             return out_proj->forward(ctx, out);
         }
     };
@@ -537,6 +597,7 @@ namespace MiniMaxH3 {
                              ggml_tensor* t_emb,
                              const std::vector<TokenModulationSpan>& segments,
                              ggml_tensor* pe,
+                             const std::string& cut_group,
                              const std::string& debug_target = {},
                              ggml_tensor** debug_output = nullptr) {
             auto norm1 = std::dynamic_pointer_cast<RMSNorm>(blocks["norm1"]);
@@ -592,6 +653,9 @@ namespace MiniMaxH3 {
                 *debug_output = x;
                 return x;
             }
+            if (ctx->max_graph_vram_bytes > 0 && !cut_group.empty()) {
+                sd::ggml_graph_cut::mark_graph_cut(x, cut_group + ".attn.output", "hidden_states");
+            }
             h      = modulate_segments(ctx->ggml_ctx,
                                        norm2->forward(ctx, x),
                                        mods,
@@ -869,11 +933,13 @@ namespace MiniMaxH3 {
             auto pe    = build_rope(ctx, position_ids);
             for (int64_t i = 0; i < config.num_layers; ++i) {
                 auto block = std::dynamic_pointer_cast<TransformerBlock>(blocks["blocks." + std::to_string(i)]);
+                const std::string cut_group = "minimax_h3.blocks." + std::to_string(i);
                 h          = block->forward(ctx,
                                             h,
                                             t_emb,
                                             segments,
                                             pe,
+                                            cut_group,
                                             i == 0 ? debug_target : std::string(),
                                             i == 0 ? debug_output : nullptr);
                 if (debug_output != nullptr && *debug_output != nullptr) {
@@ -884,7 +950,7 @@ namespace MiniMaxH3 {
                     return {nullptr, nullptr};
                 }
                 sd::ggml_graph_cut::mark_graph_cut(h,
-                                                   "minimax_h3.blocks." + std::to_string(i),
+                                                   cut_group,
                                                    "hidden_states");
             }
 
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.cpp b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
index ab005e2..6ddcc3d 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.cpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.cpp
@@ -6,6 +6,7 @@
 #include <cstdint>
 #include <cstring>
 #include <fstream>
+#include <functional>
 #include <limits>
 #include <iomanip>
 #include <regex>
@@ -51,6 +52,26 @@ struct ScopedEnvVar {
     }
 };
 
+class ScopeExit {
+public:
+    explicit ScopeExit(std::function<void()> callback)
+        : callback_(std::move(callback)) {}
+
+    ~ScopeExit() {
+        run_now();
+    }
+
+    void run_now() {
+        if (callback_) {
+            callback_();
+            callback_ = nullptr;
+        }
+    }
+
+private:
+    std::function<void()> callback_;
+};
+
 bool set_minimax_error(std::string* error, const char* message) {
     if (error != nullptr) {
         *error = message;
@@ -158,7 +179,20 @@ void h3_reference_video_dimensions(const ed_image_t& image, int* width, int* hei
     *height = std::max(32, static_cast<int>(std::round(nominal_height / 32.0)) * 32);
 }
 
-void h3_reference_image_dimensions(const ed_image_t& image, int* width, int* height) {
+void h3_reference_image_dimensions(const ed_image_t& image,
+                                   ed_ref_image_size_t size_mode,
+                                   int canvas_width,
+                                   int canvas_height,
+                                   int* width,
+                                   int* height) {
+    if (size_mode == ED_REF_IMAGE_SIZE_MATCH) {
+        const double source_area = static_cast<double>(image.width) * image.height;
+        const double canvas_area = static_cast<double>(canvas_width) * canvas_height;
+        const double scale = std::min(1.0, std::sqrt(canvas_area / source_area));
+        *width = std::max(32, static_cast<int>(std::round(image.width * scale / 32.0)) * 32);
+        *height = std::max(32, static_cast<int>(std::round(image.height * scale / 32.0)) * 32);
+        return;
+    }
     const double scale = static_cast<double>(H3_REF_IMAGE_SHORT_EDGE) /
                          static_cast<double>(std::min(image.width, image.height));
     *width = std::max(32, static_cast<int>(std::round(image.width * scale / 32.0)) * 32);
@@ -185,6 +219,15 @@ float h3_discrete_flow_sigma(int step, int steps, float shift) {
                          : shift * sigma / (1.0f + (shift - 1.0f) * sigma);
 }
 
+float h3_simple_flow_sigma(int step, int steps, float shift) {
+    if (steps <= 0 || step >= steps) {
+        return 0.0f;
+    }
+    const float sigma = static_cast<float>(steps - step) / static_cast<float>(steps);
+    return shift == 1.0f ? sigma
+                         : shift * sigma / (1.0f + (shift - 1.0f) * sigma);
+}
+
 bool h3_trace_enabled() {
     const char* value = std::getenv("ED_MINIMAX_H3_TRACE");
     return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
@@ -590,14 +633,24 @@ bool MiniMaxH3Pipeline::prepare(const ed_context_params_t& params,
                                         ? effective_budget - minimax_staging_slack
                                         : effective_budget;
     size_t remaining_free = placement_budget;
-    const bool diffusion_offload = runtime.dit_offload_params_to_cpu() ||
-                                   runtime.plan_component_offload(loader, "model.diffusion_model", remaining_free);
-    const bool text_offload = runtime.clip_offload_params_to_cpu() ||
-                              runtime.plan_component_offload(loader, "text_encoders.llm", remaining_free);
-    const bool vae_offload = runtime.vae_offload_params_to_cpu() ||
-                             runtime.plan_component_offload(loader, "first_stage_model", remaining_free);
-    const bool audio_vae_offload = runtime.vae_offload_params_to_cpu() ||
-                                   (has_audio_vae && runtime.plan_component_offload(loader, "audio_vae", remaining_free));
+    const bool diffusion_policy_offload = runtime.dit_offload_params_to_cpu() ||
+                                          runtime.plan_component_offload(loader, "model.diffusion_model", remaining_free);
+    const bool text_policy_offload = runtime.clip_offload_params_to_cpu() ||
+                                     runtime.plan_component_offload(loader, "text_encoders.llm", remaining_free);
+    const bool vae_policy_offload = runtime.vae_offload_params_to_cpu() ||
+                                    runtime.plan_component_offload(loader, "first_stage_model", remaining_free);
+    const bool audio_vae_policy_offload = runtime.vae_offload_params_to_cpu() ||
+                                          (has_audio_vae && runtime.plan_component_offload(loader, "audio_vae", remaining_free));
+    const bool lifecycle_requested = runtime.minimax_h3_stage_lifecycle() ||
+                                     (runtime.auto_fit() && runtime.max_vram() > 0.0f);
+    stage_diffusion_lifecycle_ = lifecycle_requested && !diffusion_policy_offload;
+    stage_text_lifecycle_ = lifecycle_requested && !text_policy_offload;
+    stage_video_vae_lifecycle_ = lifecycle_requested && !vae_policy_offload;
+    stage_audio_vae_lifecycle_ = lifecycle_requested && has_audio_vae && !audio_vae_policy_offload;
+    const bool diffusion_offload = diffusion_policy_offload || stage_diffusion_lifecycle_;
+    const bool text_offload = text_policy_offload || stage_text_lifecycle_;
+    const bool vae_offload = vae_policy_offload || stage_video_vae_lifecycle_;
+    const bool audio_vae_offload = audio_vae_policy_offload || stage_audio_vae_lifecycle_;
     runtime.finalize_auto_segment_budget(effective_budget, minimax_staging_slack);
 
     diffusion_ = std::make_unique<MiniMaxH3::MiniMaxH3Runner>(runtime.backend(),
@@ -727,6 +780,7 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
                                            int canvas_height,
                                            const ed_image_t* ref_images,
                                            int ref_image_count,
+                                           ed_ref_image_size_t ref_image_size,
                                            const ed_ref_video_t* ref_videos,
                                            int ref_video_count,
                                            int ref_audio_count,
@@ -840,7 +894,7 @@ bool MiniMaxH3Pipeline::build_text_context(const char* prompt,
         const ed_image_t& image = ref_images[image_index];
         int width = 0;
         int height = 0;
-        h3_reference_image_dimensions(image, &width, &height);
+        h3_reference_image_dimensions(image, ref_image_size, canvas_width, canvas_height, &width, &height);
         LOG_DEBUG("MiniMax-H3 Ref2VA vision image=%dx%d tensor=%s",
                   width,
                   height,
@@ -995,6 +1049,15 @@ ed_status_t MiniMaxH3Pipeline::decode_video_latent(const sd::Tensor<float>& late
                                                     ed_video_t* out,
                                                     MiniMaxH3Profile* profile,
                                                     std::string* error) {
+    if (stage_video_vae_lifecycle_ && !vae_->stage_params_for_phase()) {
+        set_minimax_error(error, "MiniMax-H3 failed to stage video VAE for decode");
+        return ED_STATUS_OUT_OF_MEMORY;
+    }
+    ScopeExit release_vae([this]() {
+        if (vae_ != nullptr) {
+            vae_->release_params_after_phase();
+        }
+    });
     sd::Tensor<float> vae_latent = vae_->diffusion_to_vae_latents(latent);
     h3_dump_vae_latent_if_requested(vae_latent);
     ed_tiling_params_t tiling = h3_vae_tiling(*runtime_);
@@ -1088,6 +1151,14 @@ bool MiniMaxH3Pipeline::decode_audio_latent(const sd::Tensor<float>& latent,
     if (audio_vae_ == nullptr || latent.empty()) {
         return set_minimax_error(error, "MiniMax-H3 audio VAE is not initialized");
     }
+    if (stage_audio_vae_lifecycle_ && !audio_vae_->stage_params_for_phase()) {
+        return set_minimax_error(error, "MiniMax-H3 failed to stage audio VAE for decode");
+    }
+    ScopeExit release_audio_vae([this]() {
+        if (audio_vae_ != nullptr) {
+            audio_vae_->release_params_after_phase();
+        }
+    });
     const int64_t decode_begin = profile != nullptr ? ggml_time_ms() : 0;
     sd::Tensor<float> waveform = audio_vae_->decode(runtime_->n_threads(), latent);
     if (profile != nullptr) profile->audio_vae_decode_ms += ggml_time_ms() - decode_begin;
@@ -1176,6 +1247,24 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         }
     }
     const int64_t resolved_seed = h3_resolve_seed(params->seed);
+    bool need_audio_vae_for_conditioning = params->ref_audio_count > 0;
+    for (int video_index = 0; video_index < params->ref_video_count; ++video_index) {
+        const ed_audio_t& audio = params->ref_videos[video_index].audio;
+        need_audio_vae_for_conditioning = need_audio_vae_for_conditioning ||
+                                          (audio.data != nullptr && audio.sample_count > 0);
+    }
+    const bool need_video_vae_for_conditioning = has_keyframes ||
+                                                  params->ref_image_count > 0 ||
+                                                  params->ref_video_count > 0;
+    if (stage_text_lifecycle_ && !conditioner_->model.stage_params_for_phase()) {
+        set_minimax_error(error, "MiniMax-H3 failed to stage text encoder for conditioning");
+        return ED_STATUS_OUT_OF_MEMORY;
+    }
+    ScopeExit release_text_encoder([this]() {
+        if (conditioner_ != nullptr) {
+            conditioner_->model.release_params_after_phase();
+        }
+    });
     sd::Tensor<float> context;
     sd::Tensor<int32_t> token_tags;
     const int64_t cond_context_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
@@ -1186,6 +1275,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
                             params->height,
                             params->ref_images,
                             params->ref_image_count,
+                            params->ref_image_size,
                             params->ref_videos,
                             params->ref_video_count,
                             params->ref_audio_count,
@@ -1211,6 +1301,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
                                        params->height,
                                        params->ref_images,
                                        params->ref_image_count,
+                                       params->ref_image_size,
                                        params->ref_videos,
                                        params->ref_video_count,
                                        params->ref_audio_count,
@@ -1222,6 +1313,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         return ED_STATUS_GENERATION_FAILED;
     }
     if (profile_ptr != nullptr && use_cfg) profile.uncond_context_ms = ggml_time_ms() - uncond_context_begin;
+    release_text_encoder.run_now();
     const int latent_frames = frames <= 5 ? 2 : ((frames - 5) / 17) * 5 + 2;
     const int audio_length = std::max(1, static_cast<int>(std::lround(static_cast<double>(frames) * 40.0 / 24.0)));
     const int latent_width = params->width / 16;
@@ -1229,6 +1321,15 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     std::vector<sd::Tensor<float>> keyframe_latents;
     std::vector<int32_t> keyframe_indices;
     auto request_rng = std::make_shared<PhiloxRNG>(static_cast<uint64_t>(resolved_seed));
+    if (stage_video_vae_lifecycle_ && need_video_vae_for_conditioning && !vae_->stage_params_for_phase()) {
+        set_minimax_error(error, "MiniMax-H3 failed to stage video VAE for conditioning");
+        return ED_STATUS_OUT_OF_MEMORY;
+    }
+    ScopeExit release_video_vae([this, need_video_vae_for_conditioning]() {
+        if (need_video_vae_for_conditioning && vae_ != nullptr) {
+            vae_->release_params_after_phase();
+        }
+    });
     auto add_keyframe = [&](const ed_image_t* image, int32_t frame_index, const char* name) -> bool {
         if (image == nullptr || image->data == nullptr) {
             return true;
@@ -1263,6 +1364,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     std::vector<sd::Tensor<float>> reference_latents;
     std::vector<sd::Tensor<float>> reference_audio_latents;
     std::vector<MiniMaxH3ReferenceBlock> reference_blocks;
+    std::vector<size_t> video_reference_block_indices;
     auto encode_reference_audio = [&](const ed_audio_t& source, int32_t* index) -> bool {
         if (audio_vae_ == nullptr || source.data == nullptr || source.sample_count == 0 || source.channels == 0 || source.sample_rate == 0) return false;
         const int64_t prepare_begin = profile_ptr != nullptr ? ggml_time_ms() : 0;
@@ -1297,7 +1399,12 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         }
         int reference_width = 0;
         int reference_height = 0;
-        h3_reference_image_dimensions(source_image, &reference_width, &reference_height);
+        h3_reference_image_dimensions(source_image,
+                                      params->ref_image_size,
+                                      params->width,
+                                      params->height,
+                                      &reference_width,
+                                      &reference_height);
         sd::Tensor<float> image_tensor = h3_image_to_tensor(source_image, reference_width, reference_height);
         if (image_tensor.empty()) {
             set_minimax_error(error, "MiniMax-H3 Ref2VA image reference is invalid");
@@ -1367,16 +1474,38 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
                                                   h3_vae_tiling(*runtime_));
         if (profile_ptr != nullptr) profile.reference_video_vae_encode_ms += ggml_time_ms() - vae_encode_begin;
         if (vae_latent.empty()) { set_minimax_error(error, "MiniMax-H3 Ref2VA video VAE encode failed"); return ED_STATUS_GENERATION_FAILED; }
-        int32_t audio_index = -1;
-        if (reference.audio.data != nullptr && reference.audio.sample_count > 0 && !encode_reference_audio(reference.audio, &audio_index)) {
-            set_minimax_error(error, "MiniMax-H3 Ref2VA video audio encode failed"); return ED_STATUS_GENERATION_FAILED;
-        }
         auto latent = vae_->vae_to_diffusion_latents(vae_latent);
         h3_apply_condition_noise(&latent, static_cast<uint64_t>(resolved_seed));
         h3_trace_tensor(("ref_video_" + std::to_string(video_index) + "_latent").c_str(), latent);
         const int32_t encoded_video_index = static_cast<int32_t>(reference_latents.size());
         reference_latents.push_back(std::move(latent));
-        reference_blocks.push_back({audio_index >= 0 ? MiniMaxH3ReferenceKind::VIDEO_AUDIO : MiniMaxH3ReferenceKind::VIDEO, encoded_video_index, audio_index});
+        video_reference_block_indices.push_back(reference_blocks.size());
+        reference_blocks.push_back({MiniMaxH3ReferenceKind::VIDEO, encoded_video_index, -1});
+    }
+    release_video_vae.run_now();
+    if (stage_audio_vae_lifecycle_ && need_audio_vae_for_conditioning &&
+        audio_vae_ != nullptr && !audio_vae_->stage_params_for_phase()) {
+        set_minimax_error(error, "MiniMax-H3 failed to stage audio VAE for conditioning");
+        return ED_STATUS_OUT_OF_MEMORY;
+    }
+    ScopeExit release_audio_vae([this, need_audio_vae_for_conditioning]() {
+        if (need_audio_vae_for_conditioning && audio_vae_ != nullptr) {
+            audio_vae_->release_params_after_phase();
+        }
+    });
+    for (int video_index = 0; video_index < params->ref_video_count; ++video_index) {
+        const ed_audio_t& reference_audio = params->ref_videos[video_index].audio;
+        if (reference_audio.data == nullptr || reference_audio.sample_count == 0) {
+            continue;
+        }
+        int32_t encoded_index = -1;
+        if (!encode_reference_audio(reference_audio, &encoded_index)) {
+            set_minimax_error(error, "MiniMax-H3 Ref2VA video audio encode failed");
+            return ED_STATUS_GENERATION_FAILED;
+        }
+        MiniMaxH3ReferenceBlock& block = reference_blocks[video_reference_block_indices[video_index]];
+        block.kind = MiniMaxH3ReferenceKind::VIDEO_AUDIO;
+        block.audio_index = encoded_index;
     }
     for (int audio_index = 0; audio_index < params->ref_audio_count; ++audio_index) {
         int32_t encoded_index = -1;
@@ -1386,6 +1515,7 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
         }
         reference_blocks.push_back({MiniMaxH3ReferenceKind::AUDIO, -1, encoded_index});
     }
+    release_audio_vae.run_now();
     if (h3_condition_debug_exit_enabled()) {
         if (profile_ptr != nullptr) {
             profile.total_ms = ggml_time_ms() - generation_begin;
@@ -1436,15 +1566,61 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
     }
     const int steps = params->sample.steps > 0 ? params->sample.steps : 20;
     const float video_sigma_shift = params->sample.flow_shift > 0.0f ? params->sample.flow_shift : 12.0f;
-    // Match stable-diffusion.cpp's DiscreteScheduler + FluxFlowDenoiser: `steps`
-    // model evaluations plus a terminal sigma=0 point.
+    const ed_sampler_t sampler = params->sample.sampler == ED_SAMPLER_AUTO
+                                     ? default_sample_method()
+                                     : params->sample.sampler;
+    const ed_scheduler_t scheduler = params->sample.scheduler == ED_SCHEDULER_AUTO
+                                         ? default_scheduler(sampler)
+                                         : params->sample.scheduler;
+    if (sampler != ED_SAMPLER_EULER && sampler != ED_SAMPLER_RES_MULTISTEP) {
+        set_minimax_error(error, "MiniMax-H3 currently supports Euler and RES multistep samplers");
+        return ED_STATUS_UNSUPPORTED;
+    }
+    if (scheduler != ED_SCHEDULER_DISCRETE && scheduler != ED_SCHEDULER_SIMPLE) {
+        set_minimax_error(error, "MiniMax-H3 currently supports discrete and simple schedulers");
+        return ED_STATUS_UNSUPPORTED;
+    }
+    auto sigma_at = [&](int step) {
+        return scheduler == ED_SCHEDULER_SIMPLE
+                   ? h3_simple_flow_sigma(step, steps, video_sigma_shift)
+                   : h3_discrete_flow_sigma(step, steps, video_sigma_shift);
+    };
+    LOG_INFO("MiniMax-H3 sampling: sampler=%s scheduler=%s steps=%d flow-shift=%.6g",
+             sampler == ED_SAMPLER_RES_MULTISTEP ? "res_multistep" : "euler",
+             scheduler == ED_SCHEDULER_SIMPLE ? "simple" : "discrete",
+             steps,
+             video_sigma_shift);
+    if (stage_diffusion_lifecycle_ && !diffusion_->stage_params_for_phase()) {
+        set_minimax_error(error, "MiniMax-H3 failed to stage diffusion model for denoising");
+        return ED_STATUS_OUT_OF_MEMORY;
+    }
+    ScopeExit release_diffusion([this]() {
+        if (diffusion_ != nullptr) {
+            diffusion_->release_params_after_phase();
+        }
+    });
+    sd::Tensor<float> old_denoised;
+    float old_sigma_down = 0.0f;
+    bool have_old_denoised = false;
     for (int step = 0; step < steps; ++step) {
         if (profile_ptr != nullptr) ++profile.diffusion_steps;
-        const float sigma = h3_discrete_flow_sigma(step, steps, video_sigma_shift);
-        const float sigma_next = h3_discrete_flow_sigma(step + 1, steps, video_sigma_shift);
+        const float sigma = sigma_at(step);
+        const float sigma_next = sigma_at(step + 1);
+        sd::Tensor<float> model_packed = packed;
+        float audio_sigma = sigma;
+        float audio_slope = 1.0f;
+        float audio_scale = 1.0f;
+        if (sampler == ED_SAMPLER_RES_MULTISTEP) {
+            audio_sigma = MiniMaxH3::time_shift_sigma(sigma, video_sigma_shift, 3.0f);
+            audio_slope = MiniMaxH3::time_shift_slope(sigma, video_sigma_shift, 3.0f);
+            audio_scale = video_sigma_shift / 3.0f;
+            auto model_av = diffusion_->split_av_latents(packed, audio_length);
+            model_av.second *= audio_sigma / sigma;
+            model_packed = h3_pack_audio_and_video_latents(model_av.first, model_av.second);
+        }
         sd::Tensor<float> timestep({1}, {sigma * 1000.0f});
         DiffusionParams diffusion_params{};
-        diffusion_params.x = &packed;
+        diffusion_params.x = &model_packed;
         diffusion_params.timesteps = &timestep;
         diffusion_params.context = &context;
         diffusion_params.minimax_text_token_tags = &token_tags;
@@ -1495,16 +1671,52 @@ ed_status_t MiniMaxH3Pipeline::generate_video(const ed_video_generation_params_t
             velocity = uncond_velocity + (velocity - uncond_velocity) * cfg_scale;
             if (profile_ptr != nullptr) profile.cfg_combine_ms += ggml_time_ms() - cfg_combine_begin;
         }
+        if (sampler == ED_SAMPLER_RES_MULTISTEP) {
+            auto model_av = diffusion_->split_av_latents(model_packed, audio_length);
+            auto velocity_av = diffusion_->split_av_latents(velocity, audio_length);
+            velocity_av.second = (1.0f - audio_scale) * model_av.second +
+                                 (1.0f + (audio_scale - 1.0f) * audio_sigma) *
+                                     (velocity_av.second / audio_slope);
+            velocity = h3_pack_audio_and_video_latents(velocity_av.first, velocity_av.second);
+        }
         if (h3_trace_enabled()) {
             LOG_INFO("minimax-h3 trace step=%d sigma=%.8g sigma_next=%.8g", step, sigma, sigma_next);
             h3_trace_tensor(("step_" + std::to_string(step) + "_velocity").c_str(), velocity);
         }
-        packed += velocity * (sigma_next - sigma);
+        if (sampler == ED_SAMPLER_RES_MULTISTEP) {
+            sd::Tensor<float> denoised = packed - velocity * sigma;
+            if (sigma_next == 0.0f || !have_old_denoised) {
+                packed += velocity * (sigma_next - sigma);
+            } else {
+                const float t = -std::log(sigma);
+                const float t_old = -std::log(old_sigma_down);
+                const float t_next = -std::log(sigma_next);
+                const float t_prev = -std::log(sigma_at(step - 1));
+                const float h = t_next - t;
+                const float c2 = (t_prev - t_old) / h;
+                const float phi1 = std::expm1(-h) / -h;
+                const float phi2 = (phi1 - 1.0f) / -h;
+                float b1 = phi1 - phi2 / c2;
+                float b2 = phi2 / c2;
+                if (!std::isfinite(b1)) b1 = 0.0f;
+                if (!std::isfinite(b2)) b2 = 0.0f;
+                packed = std::exp(-h) * packed + h * (b1 * denoised + b2 * old_denoised);
+            }
+            old_denoised = std::move(denoised);
+            old_sigma_down = sigma_next;
+            have_old_denoised = true;
+        } else {
+            packed += velocity * (sigma_next - sigma);
+        }
         if (h3_trace_enabled()) {
             h3_trace_tensor(("step_" + std::to_string(step) + "_packed").c_str(), packed);
         }
     }
+    release_diffusion.run_now();
     auto av = diffusion_->split_av_latents(packed, audio_length);
+    if (sampler == ED_SAMPLER_RES_MULTISTEP) {
+        av.second /= video_sigma_shift / 3.0f;
+    }
     ed_status_t status = decode_video_latent(av.first, frames, out, profile_ptr, error);
     if (status != ED_STATUS_OK) {
         return status;
diff --git a/src/dit_models/pipelines/minimax_h3_pipeline.hpp b/src/dit_models/pipelines/minimax_h3_pipeline.hpp
index f04579a..f792bc7 100644
--- a/src/dit_models/pipelines/minimax_h3_pipeline.hpp
+++ b/src/dit_models/pipelines/minimax_h3_pipeline.hpp
@@ -63,6 +63,10 @@ class MiniMaxH3Pipeline final : public DiTPipeline {
     std::unique_ptr<LLM::LLMEmbedder> conditioner_;
     std::unique_ptr<MiniMaxH3VAE::MiniMaxH3VideoVAERunner> vae_;
     std::unique_ptr<MiniMaxH3Audio::AudioVAERunner> audio_vae_;
+    bool stage_diffusion_lifecycle_ = false;
+    bool stage_text_lifecycle_ = false;
+    bool stage_video_vae_lifecycle_ = false;
+    bool stage_audio_vae_lifecycle_ = false;
     ggml_context* sentinel_ctx_ = nullptr;
     ggml_tensor* sentinel_tensor_ = nullptr;
 
@@ -73,6 +77,7 @@ class MiniMaxH3Pipeline final : public DiTPipeline {
                             int canvas_height,
                             const ed_image_t* ref_images,
                             int ref_image_count,
+                            ed_ref_image_size_t ref_image_size,
                             const ed_ref_video_t* ref_videos,
                             int ref_video_count,
                             int ref_audio_count,
diff --git a/src/edge_dit.cpp b/src/edge_dit.cpp
index d6bde5f..655bbc6 100644
--- a/src/edge_dit.cpp
+++ b/src/edge_dit.cpp
@@ -132,6 +132,7 @@ void ed_video_generation_params_init(ed_video_generation_params_t * params) {
     params->height = 1024;
     params->frames = 1;
     params->seed = -1;
+    params->ref_image_size = ED_REF_IMAGE_SIZE_MAX;
     params->strength = 0.75f;
     params->vace_strength = 1.0f;
     params->moe_boundary = 0.5f;
diff --git a/third_party/ggml b/third_party/ggml
index b067f4f..f97d927 160000
--- a/third_party/ggml
+++ b/third_party/ggml
@@ -1 +1 @@
-Subproject commit b067f4f6d48bff332fda61de57a524bb0d33da67
+Subproject commit f97d92730a995ef4d02cb8fee574b18734a0f37a