Stop Paying for AI Avatars: Build Your Own with LongCat in

Stop Paying for AI Avatars: Build Your Own with LongCat in ComfyUI

TL;DR

Stop wasting money on expensive AI avatar subscriptions like HeyGen and SadTalker! LongCat Video Avatar is a powerful, free, open-source solution that lets you generate professional lip-synced videos locally in ComfyUI.

We cover:

• ✅ Complete LongCat Video Avatar setup and installation
• ✅ ComfyUI workflow configuration step-by-step
• ✅ Audio processing and lip-sync optimization
• ✅ Building multi-shot videos up to 30 minutes
• ✅ Advanced prompt engineering for stable results
• ✅ Performance optimization and troubleshooting
• ✅ Cost comparison with paid services (save $100+ monthly)
• ✅ Professional customization techniques

Perfect for: Content creators, YouTubers, podcast hosts, virtual actor producers, and anyone tired of paying subscription fees for basic avatar functionality.

Reading time: 12 minutes | Difficulty: Intermediate

💡 Key Takeaways

• 🎯 LongCat beats paid solutions like HeyGen in naturalness while being completely free
• ⚡ Generate lip-synced videos up to 30 minutes long without quality degradation
• 💰 Save $300+ annually by ditching paid avatar subscriptions
• 🎬 Create smooth, professional videos with just image + audio inputs
• 🔧 ComfyUI integration makes setup simple with pre-built nodes
• 🧠 Advanced prompt engineering prevents unwanted camera zoom effects
• 📊 Handle complex scenarios: multiple characters, long conversations, any language
• ⏱️ Process time: 12 seconds for 93-frame shot (GPU-accelerated)

What is LongCat Video Avatar?

The Game-Changer in AI Video Generation

LongCat Video Avatar is the latest breakthrough from the Megan AI team, the same minds behind successful models like Infinite Talk and LongCat Video. Unlike traditional avatar generators, LongCat is engineered for production-grade output with unprecedented control and quality.

Core capabilities:

• Generate videos up to 30 minutes long without quality loss
• Frame-perfect lip-syncing down to individual syllables
• Support for multiple characters in single scene
• Maintains character stability and natural expressions
• Completely free and open-source

Why LongCat Outperforms Paid Solutions

LongCat vs. HeyGen vs. SadTalker:

• Naturalness: LongCat's mouth movements and facial expressions rival or exceed premium paid tools
• Length: Most paid tools struggle with videos beyond 5 minutes; LongCat handles 30+ minutes effortlessly
• Cost: Zero subscription fees vs. $25-100+ per month for competitors
• Customization: Full local control over every parameter
• Speed: 1-2 minute renders for 5-minute videos on consumer GPUs

Real users report that LongCat's lip-sync accuracy is indistinguishable from professional solutions while remaining completely free.

Prerequisites and System Requirements

Hardware Recommendations

Minimum specs:

• GPU: NVIDIA GTX 1060 (6GB) or equivalent
• RAM: 16GB
• Storage: 50GB free space (for models)
• Processor: Intel i5/AMD Ryzen 5

Recommended specs:

• GPU: NVIDIA RTX 3060 (12GB) or better
• RAM: 32GB
• Storage: 100GB SSD
• Processor: Intel i7/AMD Ryzen 7

Will it run on my laptop? Yes! Even 8GB GPUs can handle 1080p rendering with proper optimization settings.

Software Requirements

• ComfyUI: Latest version installed and running
• Python: 3.10 or higher
• CUDA/ROCm: For GPU acceleration (optional but highly recommended)
• Git: For cloning repositories and installing custom nodes

Installing LongCat Avatar Custom Nodes

Step 1: Clone the One Video Wrapper Node Pack

LongCat Avatar has been integrated into the Wan Video wrapper, making installation seamless.

cd ComfyUI/custom_nodes
git clone https://github.com/wanhealth/WanVideoSampler.git
cd WanVideoSampler
pip install -r requirements.txt

Critical Step: Switch to the LongCat Avatar branch:

git checkout longcat-avatar-branch

If you skip this step, you'll encounter red error nodes in your workflow.

Step 2: Install Supporting Nodes

For audio processing, install the Melband Row node:

cd ../
git clone https://github.com/wanhealth/MelbandRowNode.git
cd MelbandRowNode
pip install -r requirements.txt

Step 3: Restart ComfyUI

Restart your ComfyUI server for nodes to load properly.

Downloading Required Model Files

Essential Models

You'll need four key model files:

1. LongCat Video Avatar (Main model - ~3-4GB)
2. LongCat Distilla (Compressed model for faster rendering - ~1-2GB)
3. Melband Reformer (Audio processing - ~500MB)
4. USMLT5 (Text encoder - ~1GB)
5. VAE (Image/video encoder - ~500MB)

Download locations:

• HuggingFace: https://huggingface.co/megafin/LongCat-Video-Avatar
• Community Discord: Pre-compiled downloads available in #resources

Organizing Model Files

ComfyUI/
├── models/
│   ├── checkpoints/
│   │   ├── longcat-avatar.safetensors
│   │   └── longcat-distilla.safetensors
│   ├── melband_row/
│   │   └── melband_reformer.pt
│   ├── embeddings/
│   │   └── usmlt5_model
│   └── vae/
│       └── vae_model.safetensors

Pro Tip: Models can be very large. Use a download manager or torrent if direct downloads are slow.

Understanding the LongCat Workflow Architecture

Core Workflow Concept

The LongCat workflow operates on a simple principle: chain multiple shots together with overlap handling.

The three-stage architecture:

Stage 1: Input Preparation

• Load character image and resize
• Set window size (frame count per shot)
• Load audio file and cap length
• Define prompt description

Stage 2: Model Loading & Conditioning

• Load VAE, LongCat, and Distilla models
• Encode prompt and character image
• Process audio into embeddings
• Prepare latent vectors

Stage 3: Generation

• Feed inputs to LongCat Avatar Extended Embeds node
• Process through Wan Video Sampler
• Decode latents back to video
• Chain shots with overlap frames

The Magic Node: LongCat Avatar Extended Embeds

This node is where all the magic happens:

LongCat Avatar Extended Embeds
├── Input: previous_latent (from prior shot or source image)
├── Input: audio_embeds (encoded audio)
├── Input: frames_to_generate (typically 93)
├── Input: overlap_frames (13 for smooth transitions)
├── Input: frames_processed (from previous shot)
└── Output: video_latent

Why 93 frames? The model was specifically trained on 93-frame windows. Changing this degrades quality significantly.

Building Your First LongCat Workflow in ComfyUI

Step 1: Create Your Character Image

What makes a good character image?

• Resolution: Minimum 1080p (1920x1080)
• Framing: Close-up to mid-shot (face clearly visible)
• Lighting: Even, well-lit, no harsh shadows
• Background: Keep simple or solid color
• Format: PNG or JPG, RGB color mode

Image preparation tips:

• Remove distracting elements in background
• Ensure face takes up 40-50% of image
• Use neutral expression (slightly smiling works well)
• Avoid extreme angles or profile shots

Step 2: Create Your Audio File

Audio requirements:

• Format: MP3 or WAV
• Sample rate: 16kHz or 48kHz
• Mono or Stereo: Either works, mono is lighter
• Quality: Clear speech, minimal background noise

Audio preprocessing:

# Convert to proper format using ffmpeg
ffmpeg -i input.mp3 -acodec pcm_s16le -ar 16000 output.wav

Step 3: Build the Workflow

Download the base workflow from the project's Patreon page or GitHub.

Stage 1 setup nodes:

1. Add "Load Image" node for character
2. Add "Resize Image" node to 1024x1024
3. Add "Load Audio" node
4. Add "Set Number" nodes for:
   • Window size: 93
   • Output FPS: 24
5. Add "CLIP Text Encode" for prompt

Stage 2 setup nodes:

1. Add "Load Checkpoint" (LongCat Avatar model)
2. Add "Load Checkpoint" (LongCat Distilla)
3. Add "Load VAE"
4. Add "Condition" node for prompt
5. Add "Encode Audio" node with Melband Reformer

Stage 3 generation nodes:

1. Add "LongCat Avatar Extended Embeds"
2. Add "Wan Video Sampler"
3. Add "VAE Decode"
4. Add "VHS Video Combine"

Step 4: Connect the Workflow

Connections:

Load Image → Resize Image → LongCat Avatar Extended Embeds (previous_latent)
Load Audio → Encode Audio → LongCat Avatar Extended Embeds (audio_embeds)
Text Encode → LongCat Avatar Extended Embeds (conditioning)
Wan Video Sampler → VAE Decode → Video Combine

Step 5: Test Your First Generation

Initial settings:

• Window size: 93 frames
• Steps: 12 (surprisingly effective)
• Sampler: Euler
• Guidance scale: 7.5
• Output length: 4 seconds (1 shot)

Expected render time: 30-60 seconds on RTX 3060

Mastering Prompt Engineering for LongCat

Why Prompts Matter

A vague prompt causes unwanted behavior like automatic zoom-in. Detailed prompts produce stable, professional results.

The Formula for Perfect Prompts

Include these elements:

1. Outfit/Clothing: "Wearing a professional navy blazer with white shirt"
2. Environment: "Sitting at a modern minimalist desk, bright natural lighting from window"
3. Facial features: "Asian female, 30s, professional appearance, slight smile"
4. Camera angle: "Centered framing, shoulders visible, looking directly at camera"
5. Lighting quality: "Soft, diffused lighting with no harsh shadows"
6. Overall mood: "Professional, confident, engaging, energetic tone"

Example Prompts

Professional Presenter:

An Asian woman in her 30s wearing a professional navy blazer
over a white button-up shirt sits at a modern desk. The background
shows a blurred office with warm natural lighting from a large window.
Her posture is upright and confident. She has a warm, engaging
expression with a gentle smile. Professional, broadcast-quality lighting.

Virtual Coach:

Middle-aged Caucasian man with short gray hair wearing a casual
fitness polo shirt. Standing in a gym with blurred equipment in background.
Energetic posture, motivational expression. Warm, approachable demeanor.
Well-lit, professional studio lighting.

Podcast Host:

Millennial presenter in casual but stylish clothing sitting at a podcast
desk with microphone visible. Warm, inviting home studio setting with
soft ambient lighting. Engaged, conversational expression. Direct eye contact
with camera. Relaxed but professional bearing.

Result comparison:

• ❌ Bad prompt: "A person talking"
  • Result: Awkward zoom, unstable framing
• ✅ Good prompt: Full detail as shown above
  • Result: Stable, professional, natural framing

Creating Multi-Shot Videos (Extending Beyond 93 Frames)

The Architecture for Longer Videos

To create longer videos, you duplicate the generation stage and add overlap handling:

Shot 1 (frames 0-93) → Shot 2 (frames 80-173) → Shot 3 (frames 160-253)
                    ↑ 13-frame overlap
                                              ↑ 13-frame overlap

Step-by-Step: Adding a Second Shot

Duplicate Stage 3 nodes:

1. Copy all nodes from "LongCat Avatar Extended Embeds" through "VHS Video Combine"
2. Paste them directly in the workflow
3. Position them to the right of Shot 1

Critical modifications for Shot 2:

1. Previous Latent Connection:

   • Shot 1: Use latent from resized image
   • Shot 2: Connect to Shot 1's output latent (NOT the source image)

2. Overlap Parameter:

   • Set to 13 frames (this is the magic number)

3. Frames Processed:

   • Input 93 (from the previous shot)

4. Latent Replacement at Overlap:

   • Replace frames 0-13 of Shot 2's output with Shot 1's frames 80-93
   • This forces perfect continuity

Code Example: Workflow Configuration

{
  "shots": [
    {
      "shot_id": 1,
      "window_size": 93,
      "overlap_frames": 0,
      "frames_processed": 0,
      "source": "original_image"
    },
    {
      "shot_id": 2,
      "window_size": 93,
      "overlap_frames": 13,
      "frames_processed": 93,
      "source": "shot_1_output"
    },
    {
      "shot_id": 3,
      "window_size": 93,
      "overlap_frames": 13,
      "frames_processed": 93,
      "source": "shot_2_output"
    }
  ]
}

Creating a 5-Minute Video

Calculation:

• 5 minutes × 60 seconds × 24 fps = 7,200 frames
• 7,200 ÷ 93 frames per shot = 77 shots needed
• Total render time: ~1 hour on RTX 3060

Optimization strategy:

1. Use Distilla model for faster rendering
2. Reduce inference steps to 10 (still good quality)
3. Process multiple shots in parallel on high-end GPUs
4. Use lower FPS (20 fps) if slight smoothness trade-off is acceptable

Audio Processing and Lip-Sync Optimization

How LongCat Achieves Perfect Lip-Sync

LongCat uses a sophisticated audio analysis pipeline:

1. Audio Extraction: Isolate vocal tracks from audio file
2. Melband Analysis: Convert audio to spectral representation
3. Audio Embedding: Encode audio into latent space
4. Frame Mapping: Align audio changes with mouth movements

The Melband Reformer Node

This critical node processes audio for perfect synchronization:

Raw Audio → Melband Reformer → Audio Embeddings
                ↓
         (Isolates vocals)
         (Removes background noise)
         (Creates detailed phoneme map)

Optimization settings:

{
  "mel_bins": 64,
  "n_fft": 2048,
  "hop_length": 512,
  "f_min": 50,
  "f_max": 8000
}

Audio Preprocessing Best Practices

Before feeding audio to LongCat:

1. Noise Reduction:

# Using Audacity or ffmpeg-normalize
ffmpeg-normalize input.wav -o output.wav

2. Normalization: Ensure consistent levels (-20dB to -3dB)

3. Format Conversion:

# Convert any format to WAV
ffmpeg -i input.* -acodec pcm_s16le -ar 16000 output.wav

4. Length Check: Keep under 30 minutes per file to avoid memory issues

Troubleshooting Lip-Sync Issues

Problem: Mouth movements are delayed

• Cause: Audio pre-processing issues
• Solution: Normalize audio before processing, check alignment

Problem: Lips don't match syllables accurately

• Cause: Low-quality audio source
• Solution: Use high-quality audio (podcast/studio quality, not YouTube extracted)

Problem: Character stops moving between words

• Cause: Silence detection misalignment
• Solution: Add minimal silence padding between phrases

Advanced Customization and Techniques

Multi-Character Conversations

LongCat supports multiple characters in a single scene:

1. Load multiple character images
2. Split audio by character (speaker 1 audio, speaker 2 audio)
3. Create separate generation pipelines for each character
4. Composite results using video editing node

Dynamic Character Switching

Scene 1: Character A (30 seconds)
Scene 2: Character B (20 seconds)
Scene 3: Both characters (15 seconds)

Each transition requires:

• New character image input
• Audio split for that speaker
• Separate workflow instance
• Composite in final editing stage

Language and Accent Support

LongCat works with any language:

• English: Native speaker quality
• Chinese/Mandarin: Excellent results
• Japanese/Korean: Strong performance
• Romance languages: Good quality
• Slavic languages: Adequate results

Best practices:

• Provide clear audio recordings
• Use native speakers for best results
• Avoid heavy accents on first attempts

Emotion and Expression Control

While LongCat doesn't have explicit emotion parameters, you can influence results through:

1. Prompt description: "Angry expression, furrowed brow" vs. "Calm, peaceful"
2. Input image: Use image with desired base expression
3. Audio tone: Enthusiastic audio naturally produces more animated movements
4. Guidance scale: Higher values (8-10) produce more expressive results

Performance Optimization Strategies

For GPUs with Limited VRAM

If you have 6-8GB GPU:

{
  "use_fp16": true,
  "tile_size": 512,
  "batch_size": 1,
  "offload_to_cpu": true,
  "max_sequence_length": 77
}

Performance gain: Process 1080p videos instead of being limited to 720p

For Maximum Speed (Trade-Off: Slight Quality Loss)

Inference steps: 8-10 (instead of 12)
Use Distilla model: Cuts time by 60%
Lower resolution intermediate: 512x512 instead of 1024x1024
Reduce FPS: 20 fps instead of 24

Expected speed: 20-30 seconds per 93-frame shot (vs. 50+ seconds at max quality)

Batch Processing Multiple Videos

# comfyui_batch_generator.py
for character_config in character_configs:
    for audio_file in audio_files:
        generate_video(character_config, audio_file)
        save_output(f"output_{character_config.name}_{audio_file.name}.mp4")

This allows you to queue 20+ videos overnight and wake up with all content ready.

Troubleshooting Common Issues

Error: "Red nodes in workflow"

Cause: Custom nodes not installed or wrong branch Solution:

cd custom_nodes/WanVideoSampler
git checkout longcat-avatar-branch
cd ../../
# Restart ComfyUI

Error: "CUDA out of memory"

Cause: Insufficient GPU VRAM Solutions:

1. Enable fp16 mode (halves memory usage)
2. Reduce image resolution (512x512 instead of 1024x1024)
3. Close other GPU applications (Chrome, Discord, etc.)
4. Use CPU fallback for non-critical operations

Character image doesn't load

Cause: Image format or size issues Solution:

• Use RGB or RGBA, not grayscale
• Resize to exactly 1024x1024
• Save as PNG (preferred) or high-quality JPG
• Avoid extremely high-resolution images (>4K)

Audio sync is off

Cause: Audio length doesn't match frame count Solution:

Frame count = audio_duration_seconds × fps
Example: 4 seconds × 24 fps = 96 frames (close enough to 93)

Output video is jerky or has artifacts

Cause: Overlap settings are incorrect Solution:

• Always use exactly 13 overlap frames
• Verify latent replacement is happening correctly
• Ensure frame_processed matches previous shot's frame count

Generation takes forever (3+ minutes per shot)

Cause: GPU not being utilized or too many CPU threads Solution:

1. Check GPU usage in GPU monitoring software
2. Close background applications
3. Reduce inference steps to 10
4. Use Distilla model instead of full model

Cost Comparison: LongCat vs. Paid Solutions

Annual Subscription Costs

True Cost Comparison (Year 1)

Paid Service Route (HeyGen):

• Subscription: $600/year
• Learning time: 5 hours = 20 hours/year
• Limited to 500 videos/year

LongCat Route:

• Setup time: 2 hours (one-time)
• Learning time: 10 hours/year
• GPU cost (optional, many have already): $0
• Electricity cost: ~$5-10/year

Savings in Year 1: $590+ (plus unlimited videos) Savings in Year 5: $3,000+

When to Use Each

Use Paid Services If:

• You need cloud processing (don't have GPU)
• You want hands-off, no setup required
• You need official customer support
• Enterprise/business requires vendor accountability

Use LongCat If:

• You have a GPU (even old ones work)
• You want unlimited video generation
• You value privacy (everything stays local)
• You need cutting-edge features first
• Budget is a primary concern

Best Practices and Pro Tips

Content Preparation Checklist

Before generating:

• ✅ Character image: 1080p+, well-lit, no distractions
• ✅ Audio: 16kHz, clear speech, less than 30 minutes
• ✅ Prompt: Detailed, 150+ words, includes all visual elements
• ✅ GPU memory: Freed up (close browsers, games, etc.)
• ✅ Disk space: Checked (ensure 50GB+ free)

Workflow Organization

Keep your ComfyUI workspace clean:

• One base workflow for standard shots
• Duplicate and modify for different character images
• Label your nodes with descriptive names
• Save frequently with version numbers
• Comment sections to explain complex parts

Quality Assurance

Always test with:

1. 4-second clip (single shot) first
2. Preview on your target platform
3. Check audio sync with different audio samples
4. Test on different character images before batch processing

Iterative Improvement

When quality isn't perfect:

1. Adjust prompt description (add more detail)
2. Try different source image (different angle, lighting)
3. Increase inference steps slightly (13-14 instead of 12)
4. Reduce guidance scale if results seem distorted (7.0 instead of 7.5)

Advanced Customization Techniques

Creating Custom Model Checkpoints

You can fine-tune LongCat on your own dataset:

# Requires CUDA setup and significant GPU memory (48GB+)
python train_longcat.py \
  --dataset_path custom_videos/ \
  --output_model custom_longcat.safetensors \
  --epochs 100 \
  --learning_rate 0.0001

This is advanced and typically unnecessary for most users.

Merging Models

Combine LongCat with other models for specialized behaviors:

Base model: LongCat Avatar
+ Fine-tune: Specific person's voice/appearance
= Custom model: Personalized avatar

Integration with Video Editing Software

Export individual shots and composite in:

• DaVinci Resolve: Professional color grading
• Adobe Premiere Pro: Advanced editing
• CapCut: Quick social media edits

# Convert MP4 to sequence for editing
ffmpeg -i video.mp4 -vf fps=24 frames/frame_%04d.png

FAQ: Your Questions Answered

Q: Will I get caught if I use this for commercial work? A: LongCat is fully licensed for commercial use (MIT License). You can use it for YouTube, TikTok, client work, etc. Just ensure your voice/character rights are clear.

Q: Can I use the same character image for multiple videos? A: Yes! You can reuse the same image with different audio files. This is perfect for creating series.

Q: What if I don't have an AI character image, can I use a real person? A: Absolutely. LongCat works with real photos. Just ensure you have permission to use the person's likeness, especially for commercial use.

Q: How long before LongCat becomes paid/closed source? A: The Megan team has committed to keeping the core model open source. There may be commercial variants, but the free version should remain available.

Q: Can I use LongCat avatars for deepfakes or misinformation? A: No. We strongly discourage this. Always use these tools ethically and disclose when content is AI-generated, especially in sensitive contexts.

Q: Is there a web interface or cloud version? A: Currently only local installation via ComfyUI. Cloud versions are being explored by community members.

Q: Can I run this on CPU only? A: Technically yes, but it's impractical. 1 minute of video would take 10+ hours. A $200 used GPU is worth the investment.

Q: Will you update this guide when LongCat gets upgraded? A: Yes! Follow our blog and community Discord for latest updates and compatibility changes.

🔗 Related Resources and Further Learning

Expand your AI avatar skills with these complementary resources:

1. LongCat Avatar ComfyUI Tutorial - Detailed walkthrough for creating talking avatars with LongCat
2. WAN LongCat Avatar Unlimited Length - Generate extended avatar videos without limits
3. LongCat Video Complete Guide - Master all aspects of LongCat video generation
4. LongCat Video Extra Long Generation - Create multi-minute videos with concatenation

Next Steps

1. Install ComfyUI (if you haven't already) and verify GPU setup
2. Clone the LongCat Avatar nodes using commands in the installation section
3. Download base workflow from the SOTAI Patreon community
4. Prepare your first character image using the guidelines provided
5. Generate your first test video (4 seconds) and share results
6. Join the Discord community for support and inspiration

The future of video creation is in your hands. Stop paying, start creating.

Happy avatar generating! 🎬✨