Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > Comfyui-SenseNova-U1.5-Wrapper-T8

ComfyUI Extension: Comfyui-SenseNova-U1.5-Wrapper-T8

Repo Name

Comfyui-SenseNova-U1.5-Wrapper-T8

Author
T8mars (Account age: 1793 days)
Nodes
View all nodes(1)
Latest Updated
2026-11-04
Github Stars
0.03K

How to Install Comfyui-SenseNova-U1.5-Wrapper-T8

Install this extension via the ComfyUI Manager by searching for Comfyui-SenseNova-U1.5-Wrapper-T8
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter Comfyui-SenseNova-U1.5-Wrapper-T8 in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

Comfyui-SenseNova-U1.5-Wrapper-T8 Description

Comfyui-SenseNova-U1.5-Wrapper-T8 enables local image generation and multi-reference editing in ComfyUI, with planning-assisted creation, interleaved text-image sequences, GGUF models, and fast LoRA.

Comfyui-SenseNova-U1.5-Wrapper-T8 Introduction

Comfyui-SenseNova-U1.5-Wrapper-T8 brings SenseNova-U1.5 image generation and editing into ComfyUI through native, locally running nodes. You can create images from descriptions, edit existing artwork, combine multiple visual references, or generate a sequence of related text and images—all within a visual workflow.

The extension connects SenseNova-U1.5 to ComfyUI’s existing tools for sampling, scheduling, LoRA application, and GPU memory management. This means you can use familiar nodes such as KSampler, VAE Decode, and Save Image instead of working with separate inference scripts.

What you can create

  • Text-to-image artwork: Generate illustrations, portraits, product images, posters, and other visuals from natural-language prompts.
  • Thinking-assisted images: Let the model perform a planning stage before image generation.
  • Illustrated sequences: Generate text and images together, with earlier generated images informing what comes next.
  • Single-image edits: Describe a change to an existing image.
  • Multi-reference edits: Use 1–10 reference images, assigning a different purpose to each.
  • Variations: Generate 1–16 different results from the same prompt and reference set.
  • Faster text-to-image drafts: Use the supported official 8-step LoRA with U1.5 Final.
  • Quantized-model workflows: Choose among five supported Final GGUF files to explore different model-size, quality, and performance trade-offs.

For example, you can ask the model to dress the person in Image-1 using the outfit in Image-2, while preserving the original face, pose, lighting, and background. Explicit reference roles help reduce unwanted copying, such as transferring a clothing mannequin into the final scene.

Local operation: The extension reads model files already stored on your computer. It does not download models during generation, and model weights are not included with the extension.

SenseNova-U1.5 has broader capabilities than those exposed here. Upstream features such as bounding-box and visual-marker control are not currently available through this wrapper.

How Comfyui-SenseNova-U1.5-Wrapper-T8 Works

One model works with both words and images

SenseNova-U1.5 is a unified multimodal model: it handles language and visual information within the same underlying architecture.

Think of it as an artist who can read a brief, study reference pictures, and create a new image using both. For editing, the model receives your written instructions alongside the reference images rather than simply treating the original image as a starting canvas of noise.

The underlying NEO-unify architecture works directly with pixel and language information without the separate visual encoder and conventional VAE used by many other image-generation systems. The wrapper still provides ComfyUI-compatible MODEL, CLIP, and VAE interfaces so standard workflow nodes can be used.

The basic image-generation path

SenseNova Loader
    ↓
SenseNova Sampling Options
    ↓
KSampler
    ↓
VAE Decode
    ↓
Save Image

This diagram shows the main model-and-image path. Your workflow also connects encoded prompts and an empty pixel latent to the sampler.

ComponentPlain-language explanation
LoaderOpens the supported local model file.
Text encodingPrepares your written description for the model.
Empty pixel latentDefines the output dimensions and number of images.
Sampling OptionsApplies SenseNova sampling settings, including shift, and enables task-local prefix caching.
SamplerBuilds the image over a series of steps.
VAE DecodeConverts the sampling output into ComfyUI’s image output format.
Save ImageSaves the finished result.

Important: Pass MODEL through SenseNova Sampling Options before sampling. The recommended starting value for shift is 3.

How reference-based editing works

Reference images are connected to a SenseNova reference node. The extension labels them Image-1, Image-2, and so on, matching the order used in your prompt.

Each image is handled separately, including its dimensions. The extension does not simply stitch all references into one large picture.

For example:

Image-1: the person whose identity and pose should be preserved
Image-2: the clothing to transfer

Your prompt then explains what each reference contributes and what must remain unchanged.

How thinking and interleaved generation differ

  • Thinking text-to-image: The model first generates a planning stage, then samples an image. You can inspect the model-generated thinking text after sampling with the dedicated preview node.
  • Interleaved generation: The model alternates between text and image events. Each generated image is fed back into the context before the model continues, rather like building an illustrated guide one section at a time.

These are different from batch generation. A batch creates several alternatives from one brief; interleaving creates an ordered sequence of text and images.

Why prefix caching helps

Your prompt and reference images remain the same during many sampling steps. Reprocessing them at every step would repeat work.

SenseNova Sampling Options stores their reusable internal representation in a prefix KV cache for the current task. Think of this as keeping reference notes on the desk instead of rereading the entire brief before every brushstroke.

For batches, shared text and reference information is computed once per guidance branch rather than fully repeated for every output.

The cache:

  • Exists only during the current task.
  • Is cleared when the task finishes, fails, or is cancelled.
  • Is not saved between tasks.
  • Produced element-for-element identical results to the uncached path in the documented three-way editing comparison.

Comfyui-SenseNova-U1.5-Wrapper-T8 Features

Text-to-image generation with standard sampling

You can use ordinary natural-language descriptions with the standard KSampler workflow.

Start with the author’s recommended baseline:

SettingStarting valueWhat it affects
Steps50Number of sampling iterations.
CFG4Strength of text guidance; excessive values can exaggerate colors or detail.
img_cfg1Image-reference guidance used in editing.
Shift3SenseNova’s sampling schedule adjustment.
SamplereulerThe sampling method.
SchedulernormalHow sampling steps are distributed.
Denoise1The recommended full sampling range for these workflows.

Use this baseline before experimenting. Changing one setting at a time makes it easier to understand why a result changed.

Thinking-assisted text-to-image

To enable the planning stage:

  1. Replace CLIP Text Encode with SenseNova 1.x Text Encode.
  2. Set mode=image.
  3. Enable thinking on the positive prompt.
  4. Start with max_think_tokens=512.
  5. Keep thinking=false on the negative prompt.
  6. Connect the same positive conditioning and the KSampler samples output to SenseNova Thinking Preview.

max_think_tokens is a limit on the planning text, not the image sampling step count.

Thinking adds work before image sampling begins and uses additional KV-cache GPU memory. A delay before the first visible sampling step is therefore expected.

Interleaved text and image generation

This feature is useful for illustrated tutorials, visual narratives, and other content that benefits from an ordered mixture of writing and pictures.

To use the supplied workflow:

  1. Set both positive and negative text encoders to mode=interleave.
  2. Connect them to SenseNova 1.x Interleave.
  3. Use the workflow’s KSamplerSelect, BasicScheduler, and pixel latent connections.
  4. Set max_images to limit the number of generated images.
  5. Decode the image output with VAE Decode.
  6. Connect the decoded images to SenseNova Interleave Preview to view the sequence in its original order.

After each image event, the node samples the image, updates the positive and negative KV prefixes, and continues generating.

Single-image and multi-reference editing

Choose the reference node according to your task:

NodeReference inputsWhen to use it
SenseNova Reference ImageImage-1, plus optional Image-2Single-image editing and common two-reference tasks.
SenseNova Reference Images (1-10)1–10 imagesTasks requiring three or more references.

The simpler node intentionally has no extra blank third slot.

Older workflows using the images.image input name are migrated automatically on import. Older workflows with more than two references are also migrated to the 1–10-reference node.

For ordinary editing with img_cfg=1:

  • Connect your picture to SenseNova Reference Image.
  • Do not use the reference image as the sampler’s latent input.
  • Connect the node’s image_condition output to the KSampler negative input, following the supplied editing workflow.

Structured prompts for more predictable edits

SenseNova Structured Edit Prompt helps divide a complex request into four clear parts:

  1. Main change: What should be edited?
  2. Reference roles: What should each image contribute?
  3. Preserve: What must stay the same?
  4. Avoid: What must not appear or change?

You can also write the same structure directly in CLIP Text Encode:

[Main change]
Dress the person in Image-1 in the outfit shown in Image-2.

[Reference roles]
Image-1 provides the person.
Image-2 provides only the clothing. Do not copy its mannequin or background.

[Preserve]
Keep the face, pose, lighting, background, and framing from Image-1 unchanged.

[Avoid]
Do not add a second person. Do not change unspecified areas.

This gives the model a clearer brief than “make her wear this outfit.” It can improve control, but it does not guarantee perfect preservation in difficult edits.

Custom image guidance and CFG normalization

Use SenseNova Edit Guider when you need three-way guidance, custom img_cfg, CFG normalization, or a restricted CFG interval.

If img_cfg is not 1, use SenseNova Edit Guider with SamplerCustomAdvanced, not the ordinary KSampler path.

The same MODEL output from SenseNova Sampling Options must connect to both the guider and the scheduler:

SenseNova Sampling Options — MODEL
    ├── SenseNova Edit Guider ── guider ──┐
    └── BasicScheduler ──────── sigmas ──┤
RandomNoise ─────────────────── noise ────┤
KSamplerSelect ──────────────── sampler ──┤
Pixel latent ───────────────── latent ───┘
                              ↓
                    SamplerCustomAdvanced

For complex edits, start with:

CFG: 4
img_cfg: 1
cfg_norm: global
cfg_interval: 0 → 1

CFG normalization options

OptionEffectWhen to try it
noneNo additional CFG normalization.A comparison baseline, or when normalized results are too restrained.
globalRescales excessive guidance relative to the positive-conditioned output.Oversaturated colors, oversharpening, or subject drift.
channelNormalizes separately for each 32×32 generation token.Local areas that become overemphasized.

Increasing img_cfg is not automatically a better way to preserve a person or achieve a stronger edit. The supplied stable multi-reference workflow prioritizes identity and composition using CFG=4, img_cfg=1, and global normalization.

CFG interval

cfg_interval controls when CFG applies during normalized denoising progress:

  • 0: the first step.
  • 1: the last step.
  • 0 → 1: guidance throughout sampling.

Both interval endpoints are included. The wrapper deliberately honors both boundaries, including when the start is 0.

Batch generation: 1–16 alternatives

Set batch_size in Empty SenseNova Pixel Latent to generate multiple results.

  • 1: one output.
  • 2–16: several alternatives from the same prompt.
  • Batch editing shares the same reference set across all outputs.
  • Save Image saves the results individually.

More images require more GPU memory. The batch example starts at 768×768 with batch_size=2; the fully tested batch-editing case is 512×512, batch_size=2.

For a 24 GB GPU, start with 512 or 768 pixels and two images, then increase gradually. Do not begin with 2048×2048 and a batch of 16.

Official 8-step LoRA for faster text-to-image

The dedicated SenseNova U1.5 8-Step LoRA node applies the supported adapter through ComfyUI’s native LoRA and ModelPatcher system. It also checks that the base model is compatible.

Use this path:

SenseNova Loader (Final)
    ↓
SenseNova U1.5 8-Step LoRA
    ↓
SenseNova Sampling Options
    ↓
KSampler

Recommended settings:

LoRA strength: 1
steps: 8
CFG: 1
cfg_norm: none
shift: 3
sampler: euler
scheduler: normal
denoise: 1

At CFG=1, no additional CFG normalization is applied.

Use this adapter for text-to-image. For editing, the author recommends the 50-step workflow without the LoRA.

Resolution presets

Empty SenseNova Pixel Latent includes these official recommended presets:

Aspect ratioResolutionTypical use
1:12048 × 2048Square artwork and layouts.
16:92720 × 1536Landscape compositions.
9:161536 × 2720Vertical compositions.
2:31664 × 2496Portrait-format designs.
3:22496 × 1664Landscape-format designs.

Choose Custom to use the node’s width and height fields.

Although upstream U1.5 describes native 4K generation, the wrapper’s documented full-model high-resolution examples are primarily at 2048×2048. Treat larger jobs as workload-dependent rather than guaranteed.

Comfyui-SenseNova-U1.5-Wrapper-T8 Models

Choose a model by your goal

  • Recommended general starting point: Final BF16.
  • Comparing training-stage behavior: SFT.
  • Exploring smaller model files: Final GGUF; Q3_K_M is the suggested lower-memory starting point.
  • Prioritizing quantized-model quality: Q8_0, with substantial memory requirements.
  • Faster text-to-image: Final plus the supported ComfyUI-format 8-step LoRA.

Supported base models and adapter

FileApproximate sizePurpose and compatibility
SenseNova-U1.5-8B-MoT-BF16-T8.safetensors35 GBRecommended Final model. Supports 50-step text-to-image and editing.
SenseNova-U1.5-8B-MoT-T8.safetensors50 GBOlder mixed-precision Final file. Still supported if you already have it.
SenseNova-U1.5-8B-MoT-SFT-T8.safetensors35 GBSeparate SFT model for 50-step generation and editing. Do not apply the 8-step LoRA.
SenseNova-U1.5-8B-MoT-LoRA-8step-ComfyUI.safetensors815 MBSupported official fast-generation adapter in ComfyUI-compatible format. Requires Final.

The newer Final BF16 file is an official all-BF16 conversion and re-sharding of the same Final model—not a separate training stage.

SFT is different. It represents an earlier training stage, while Final includes additional post-training. You can compare their outputs, but the documentation does not establish that SFT is universally better for a particular art style or task.

Supported Final GGUF models

GGUF quantization stores model weights more compactly. Smaller files can help with memory constraints, but file size alone does not predict generation speed, total runtime memory, or image quality.

FileApproximate sizeSelection guidance
SenseNova-U1.5-8B-MoT-Q2_K.gguf9.26 GBSmallest supported file; strict file validation is included, but it was not part of the documented hardware sampling matrix.
SenseNova-U1.5-8B-MoT-Q3_K_M.gguf10.92 GBSuggested starting point for lower-memory GGUF experiments.
SenseNova-U1.5-8B-MoT-Q5_K_M.gguf15.11 GBSupported and strictly validated; not part of the documented hardware sampling matrix.
SenseNova-U1.5-8B-MoT-Q6_K.gguf17.24 GBDocumented text-to-image, editing, and 8-step LoRA tests.
SenseNova-U1.5-8B-MoT-Q8_0.gguf21.17 GBQuality-prioritized quantization; close to the memory limit on the tested 24 GB GPU.

Use SenseNova U1.5 GGUF Loader (Final) for these workflows. It dequantizes weights as needed while retaining ComfyUI’s native sampling, scheduling, LoRA, and memory-offloading interfaces.

A separate ComfyUI-GGUF extension is not required.

Final GGUF plus the supported 8-step LoRA is supported, but the author recommends verifying a normal 50-step workflow first.

Unsupported or unconfirmed combinations

  • U1.5 Preview: Not supported, including Preview GGUF files.
  • SFT plus the 8-step LoRA: Not supported.
  • Unconverted official raw LoRA: Not directly supported; use the provided -ComfyUI file.
  • Q4 Final GGUF: Not offered as a validated option because it was not published in the referenced model repository.
  • Other U1-family and specialized checkpoints: Their presence in the upstream model collection does not establish compatibility with this wrapper.
  • Upstream 8-step LoRA V2: Available upstream, but support for that specific revision is not established in the provided wrapper documentation.

Model resources and file locations

Download the wrapper-compatible files from:

For the wrapper’s loaders, the documented locations are:

File typeLocation
Base .safetensors modelsComfyUI/models/diffusion_models/
LoRAComfyUI/models/loras/
GGUFComfyUI/models/gguf/

The extension validates model identity and integrity, including file size, SHA256 fingerprint, tensor names, shapes, and supported storage types. This prevents an incomplete or incompatible model from being silently loaded.

Comfyui-SenseNova-U1.5-Wrapper-T8 Workflows and Examples

The supplied JSON files are ComfyUI canvas workflows, not API-format workflows. Download a workflow and drag it onto the ComfyUI canvas. For editing examples, select your own images in the Load Image nodes.

Ready-to-use workflows

GoalWorkflow
Standard text-to-imageText-to-image
Thinking-assisted generationThinking text-to-image
Ordered text/image sequencesInterleaved generation
Multiple alternativesBatch text-to-image, two outputs by default
Faster generation8-step LoRA text-to-image
Ordinary editingImage editing with img_cfg=1
Reference-based clothing transferStable multi-reference editing
Quantized text-to-imageGGUF text-to-image
Quantized editingGGUF image editing
SFT generationSFT text-to-image
SFT editingSFT image editing

Workflow screenshots

Text-to-image

SenseNova text-to-image workflow showing the connected ComfyUI nodes

Ordinary image editing

SenseNova editing workflow showing the reference-image and sampling connections

ComfyUI core-native alternatives

Two additional workflows use ComfyUI’s built-in CheckpointLoaderSimple instead of this repository’s custom loader:

These require a ComfyUI version containing PR #15922. Their base models belong in ComfyUI/models/checkpoints/, not the wrapper loader’s diffusion_models folder.

The core implementation reuses EmptyHiDreamO1LatentImage and HiDreamO1ReferenceImages; those node names are expected. Its LoRA path can use built-in LoraLoaderModelOnly.

The wrapper’s thinking and interleave nodes are aligned with the implementation proposed in ComfyUI core PR #16032. The supplied documentation describes that PR as not yet merged; the wrapper workflows do not require you to switch to that core implementation.

Documented visual results

Two-reference clothing transfer, 2048×2048

A two-reference clothing-edit result generated with SenseNova U1.5

Open original image

The documented run used Final, 50 steps, CFG 4, img_cfg=1, global CFG normalization, shift 3, and Euler/normal. The first reference supplied the person and scene; the second supplied the outfit. The author reports approximately 506 seconds on an RTX 5090 Laptop with 24 GB VRAM.

SFT text-heavy generation, 2048×2048

A Chinese-language cooking infographic generated with the SFT model

Open original image

The documented SFT run used 50 steps and CFG 4, with approximately 297 seconds on the same GPU. The text was generated directly, without later text correction.

Q6_K GGUF text-to-image, 512×512

A glass teapot generated using the Q6_K GGUF model

Open original image

The 50-step run took approximately 288 seconds for core sampling after quantization-operator warm-up. A separate Q6_K plus 8-step LoRA test recorded approximately 19.9 seconds for core sampling.

These are individual measurements, not promised generation times. Resolution, model format, warm-up, offloading, and hardware all affect performance. See the GGUF validation report for test conditions and comparison boundaries.

What's New with Comfyui-SenseNova-U1.5-Wrapper-T8

See the changelog and GitHub Releases for the complete release history. The provided documentation identifies the following changes without assigning each one a version number:

ChangeWhy it matters for your work
Support for the newer 35 GB Final BF16 fileA smaller recommended Final download while retaining compatibility with the older 50 GB file.
Separate Final and SFT supportYou can compare two training stages without confusing their weights or LoRA requirements.
Five validated Final GGUF formatsMore choices for model size and quantized-image experiments.
Native 8-step LoRA application and compatibility checksFaster text-to-image with clearer feedback when the wrong base model is connected.
Thinking and interleaved workflowsPlanning-assisted images and ordered illustrated content within ComfyUI.
Batch generationSeveral alternatives from the same brief in one task.
Separate simple and 1–10-reference nodesCleaner common workflows without losing multi-reference support.
Automatic migration of older reference inputsOlder workflows can import with less manual repair.
Structured editing prompts and advanced guidanceMore explicit reference roles, preservation instructions, and control over excessive guidance.
Task-local prefix cachingLess repeated processing of unchanged text and reference inputs.
Inclusive CFG interval boundariesBoth the selected start and end positions are honored.

Version-specific troubleshooting note

For checkpoint key mismatch, the author specifically recommends version 1.3.5 or later, followed by a full ComfyUI restart. No additional version-by-version history is established in the supplied material.

  • August 20, 2026: U1.5 Final and the original 8-step LoRA were released, with improvements to instruction following, text/layout generation, editing, and high-resolution imagery.
  • September 11, 2026: The U1.5 technical report was released.
  • September 24, 2026: Upstream released 8-step LoRA V2, reporting improved color balance, more natural contrast, and reduced oversharpening.

The V2 announcement does not confirm compatibility with this wrapper’s validated LoRA file.

Comfyui-SenseNova-U1.5-Wrapper-T8 Requirements and Limitations

Documented test environment

The author reports hardware testing with:

  • NVIDIA CUDA and BF16.
  • RTX 5090 Laptop GPU with 24 GB VRAM.
  • 64 GB system RAM.
  • ComfyUI v0.33.x.

Automated compatibility checks cover ComfyUI 0.31 and v0.34.0, and Python 3.10, 3.12, 3.13, and 3.14.

Documented completed workloads include:

  • 2048×2048, 50-step text-to-image.
  • 2048×2048, two-reference editing.
  • 512×512, batch size 2 full-model execution.

Model loading and offloading also consume substantial system memory. The author recommends 64 GB RAM and sufficient virtual memory.

A model’s download size is not its total VRAM requirement. Even the documented Q6_K 512×512 run approached 24 GB device usage.

Current limitations

  • Only NVIDIA CUDA + BF16 has been validated.
  • FP16, ROCm, MPS, DirectML, XPU, and NPU operation is unverified.
  • Bounding-box and visual-marker controls are not exposed.
  • Complex replacements, multi-region edits, and many simultaneous constraints can cause content drift.
  • Dense, small, rotated, vertical, or mixed-language text can contain errors.
  • Small faces, hands, limbs, exact object counts, and strict alignment remain challenging upstream.
  • Q8_0 is close to the tested 24 GB GPU’s memory limit.
  • Q2_K and Q5_K_M have strict file validation but lack documented sampling tests in the supplied hardware matrix.

General ComfyUI support for other hardware or very low-memory workflows does not establish that this particular model and wrapper will work under the same conditions.

Troubleshooting Comfyui-SenseNova-U1.5-Wrapper-T8

“Checkpoint key mismatch” appears

  1. Update the extension to 1.3.5 or later.
  2. Fully close ComfyUI, then restart it.
  3. Check ComfyUI/custom_nodes/ for duplicate copies of this extension.
  4. Confirm that your model is a supported Final or SFT single-file checkpoint.
  5. Check the complete error message. Newer errors show both model= and loader= paths, helping identify an old loader or unintended model file.
  6. Compare the download’s size and SHA256 fingerprint with the original repository documentation.

Do not delete reported keys, modify the loader, or disable dynamic loading to bypass validation. An incorrectly loaded model may run but produce blur, color errors, or poor prompt following.

The model is missing from the loader

  1. Confirm that the model file has actually been downloaded; acquiring the nodes does not acquire the weights.
  2. Check the file location:
    • Wrapper base models: models/diffusion_models/
    • GGUF: models/gguf/
    • LoRA: models/loras/
    • Core-native checkpoint workflows: models/checkpoints/
  3. Confirm that the workflow uses the correct loader.
  4. Check that you have not selected Preview or another unsupported checkpoint.

The nodes will not download a missing model during execution.

Model validation fails

  1. Read the error to identify the file being checked.
  2. Verify the complete filename and expected model variant.
  3. Compare the file size and SHA256 fingerprint with the published values.
  4. If the file is incomplete or differs from the validated release, obtain the correct file from the linked model collection.
  5. Keep validation enabled.

A SHA256 fingerprint is a way to check that your downloaded file exactly matches the expected release.

Colors are too vivid or the image looks oversharpened

  1. Remove prompt terms such as bright, vivid, neon, or highly saturated if they are not essential.
  2. Start at CFG=4.
  3. If necessary, try CFG=3–3.5.
  4. Keep img_cfg=1 initially.
  5. For editing, try cfg_norm=global.
  6. Add phrases such as natural colors or restrained color grading.

If global normalization makes the result too conservative, compare it with none.

Editing a SenseNova-generated image produces a broken result

The upstream project has confirmed a case where reusing the original generation seed for a subsequent edit can cause distribution shift and severe image degradation.

  1. Change the editing sampler’s seed to a value different from the source generation seed.
  2. Run the edit again.
  3. If the problem continues, try the nearest official resolution preset.

See the upstream explanation and workaround.

A clothing edit changes the face, background, or pose

  1. Check that Image-1 is the person and Image-2 is the clothing reference.
  2. State that Image-2 supplies clothing only.
  3. Explicitly preserve the face, pose, lighting, background, and framing.
  4. Explicitly forbid copying a mannequin, background, or second person.
  5. Start with CFG=4, img_cfg=1, and cfg_norm=global.
  6. Compare your graph with the stable multi-reference workflow.

Some drift is a model limitation, particularly when many regions must remain unchanged.

Custom image guidance is not behaving correctly

  1. If img_cfg differs from 1, use SenseNova Edit Guider and SamplerCustomAdvanced.
  2. Ensure the same Sampling Options MODEL output feeds both Edit Guider and BasicScheduler.
  3. Return to the baseline settings before adjusting guidance.
  4. Check your wiring against the supplied multi-reference workflow.

The 8-step LoRA is rejected or gives unexpected results

  1. Use Final, not SFT or Preview.
  2. Select the supported file ending in -ComfyUI.safetensors.
  3. Keep LoRA strength at 1.
  4. Use 8 steps and CFG 1.
  5. Keep shift 3, Euler/normal, and denoise 1.
  6. Verify ordinary 50-step generation first if using GGUF.

For editing, return to the no-LoRA 50-step workflow.

GPU memory runs out

  1. Reduce batch_size to 1.
  2. Reduce output dimensions.
  3. Reduce the number of references while testing the workflow.
  4. For two-output experiments on a 24 GB GPU, begin at 512 or 768 pixels.
  5. Consider Q3_K_M as the documented lower-memory GGUF starting point.
  6. Check system RAM and virtual-memory availability, since offloading also needs memory outside the GPU.

There is no documented minimum GPU-memory guarantee for smaller cards. Upstream command-line recommendations for other inference engines should not be treated as wrapper-specific requirements or guarantees.

GGUF is unexpectedly slow

  1. Distinguish the first run from later runs: quantization operators can have substantial cold-start overhead.
  2. Compare timings at the same resolution, sampling settings, and model format.
  3. Do not assume the smallest file is the fastest.
  4. Review the GGUF validation report.
  5. If your goal is faster text-to-image, evaluate the supported 8-step LoRA after confirming the standard path works.

Small or rotated text becomes damaged

This is a known model limitation, especially during editing.

  1. Check spelling and spacing at full resolution.
  2. Make the intended text, hierarchy, and layout explicit in the prompt.
  3. Review the upstream best-practices guide before retrying.
  4. Treat small, vertical, angled, or densely packed text as needing especially careful inspection.

See the upstream text-editing limitation. Correct large headings do not guarantee that all smaller text is correct.

Frequently asked questions

Does this require a paid API?
No. This wrapper performs local inference using local model files.

Do I need to download every model?
No. Select the base model or GGUF file for your chosen workflow. Download the LoRA only if you want the supported 8-step text-to-image path.

Is the 35 GB BF16 Final a different model from the older 50 GB Final?
It is a different precision/storage release of the same Final model. SFT, by contrast, is a separate training-stage checkpoint.

Can I use ordinary KSampler?
Yes, for standard text-to-image and ordinary editing with img_cfg=1. Custom image guidance requires the advanced guider path.

Can each image in an editing batch use different references?
The documented batch-editing path shares one reference set across all results.

Do I need ComfyUI-GGUF?
No. The wrapper provides its own Final GGUF loader.

Will the cache keep occupying GPU memory between jobs?
No. It is cleared at the end of the current task, including cancellation or failure.

Can I use the upstream U1 infographic or interleaved checkpoints?
Compatibility is not established here. The supplied wrapper workflows use the supported U1.5 models.

Learn More about Comfyui-SenseNova-U1.5-Wrapper-T8

Workflow guidance and examples

Model documentation

For actual wrapper use, prefer the compatible files listed in this README over assuming that any upstream file can be loaded directly.

Community learning

Comfyui-SenseNova-U1.5-Wrapper-T8 Sources and License

SenseNova-U1.5 and its reference implementation come from OpenSenseNova/SenseNova-U1, whose original project uses the Apache License 2.0.

The author’s repository provides local ComfyUI inference adaptation and does not include model weights. See NOTICE for detailed attribution, and consult the relevant upstream model pages for their licensing information.

Comfyui-SenseNova-U1.5-Wrapper-T8 Related Nodes

RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.