More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Comfyui Local Generator

    1

    The problem Local ComfyUI makes a beautiful promise: zero API bills, full privacy, node-level control.

    $5.90

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    comfyui-local-generator

    comfyui-local-generator

    Example session with this skill installed

    I have an RTX 4060 Ti 8GB, 32GB RAM, latest ComfyUI + Manager. I downloaded FLUX.1 dev GGUF Q5 and ComfyUI-GGUF, but every run dies with CUDA out of memory before KSampler. I thought the quantized model was supposed to fit 8GB? Also I grabbed the fp16 T5 "for better quality". And I want a script to batch 5 seeds.

    • Read your context and instructions
    • Compiled the comfyui-local-generator

    Verdict: The killer isn't your main model — Q5 weights are ~5.5GB. The fp16 T5 you grabbed "for better quality" is 9.4GB, which alone fills an 8GB card. You quantized half the pipeline and paid full price for the other half.

    VRAM Budget (what the sheet caught):

    ItemEstimate
    flux1-dev-Q5_K_S.gguf (Unet Loader GGUF)~5.5 GB
    t5xxl fp16 ← yours~9.4 GB ← the killer
    ae.safetensors (VAE)~0.3 GB
    latent @1024², batch 1~1 GB
    Total~16.2 GB vs 8 GB ✗

    Repair (one variable per round):

    RoundChangeResult
    1T5 fp16 → fp8_e4m3fn (4.7 GB, near-zero quality loss)~11.5 GB — still over
    2T5 → CPU offload (encodes once per prompt, costs seconds)~6.8 GB ✅ image out

    Fits and runs. If you want T5 back on GPU for speed: Q4_K_S main model (~4 GB) + fp8 T5 is the next rung to test.

    Delivered: seed-grid batch script (5 seeds, UI→API format conversion, serial POST to localhost:8188/prompt) + required_models.txt with exact filenames and folders — your fp16 T5 can be deleted, freeing 9.4 GB of disk too.

    Honest hardware verdict on video: Wan 2.1 GGUF @480p / ≤81 frames: feasible on your card. HunyuanVideo 13B quantized: borderline gamble, not recommended for stability.

    [verify] VRAM figures are community-tier estimates (±15%, varies with driver/PyTorch version). Log actual readings from your own Task Manager.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    The problem Local ComfyUI makes a beautiful promise: zero API bills, full privacy, node-level control. The reality is another story — CUDA out of memory right before KSampler, red nodes everywhere, model files in the right folder that still never show up in the list, workflow JSONs copied from the internet that crash on first run. And the generic LLM's advice is always the same three correct-but-useless lines: "lower the resolution," "try --lowvram," "use a quantized model." It doesn't know the thing that exploded was your T5, not your main model. It doesn't know your card has 8GB. It doesn't know that since March 2026, --lowvram may simply be ignored by Dynamic VRAM. What it does

    • VRAM Budget sheet: accounts before queuing — main model + text encoder + VAE + branch models + latent working memory, item by item; over 90% means downgrade first, never gamble on OOM
    • Staged OOM triage: pinpoints the culprit by where it dies (load / encode / sample / VAE / video), each stage with its own fix ladder, one variable per round
    • Workflow health check: red nodes, missing custom node packs, model paths, UI vs API format validation — because a JSON is not "ready to run"
    • API automation: UI↔API format conversion, localhost:8188 queueing, serial batch scripts, seed-grid parameter sweeps
    • Honest hardware verdicts: what your card can and cannot run, said plainly (FLUX GGUF ✅ / LTX-13B ❌), with the nearest feasible alternative when it can't Why this beats prompting it yourself Ask a generic AI "how do I fix ComfyUI OOM" and it dumps every possible fix at once — lower resolution, change quantization, Tiled VAE, add flags. You try them all, which means changing five variables simultaneously; even if it works, you don't know which one did, and it breaks again next time. Worse, it doesn't know two lethal facts: the T5 text encoder often blows up before your main model does (the fp16 file is ~9.4GB — alone it fills an 8GB card; quantize the main model but not the encoder and you've saved half the ticket price); and --lowvram may be ignored under Dynamic VRAM in current ComfyUI, so stacking flags from old tutorials is wasted effort. This Skill locates the failure by stage, changes one variable per round, logs VRAM readings each round — fixed once means actually fixed. Use cases
    • Running FLUX/SDXL/Wan video on an 8GB/12GB card with repeated OOMs — you want the answer to "what exactly is exploding," not a list of things to try
    • A community workflow JSON full of red nodes / invisible models / instant crashes — needs a health check and repair
    • Batch image generation (seed grids / prompt variants) — needs UI→API conversion plus serial automation scripts
    • Deciding what your 8GB can actually run before buying more storage or a new GPU — with real verdicts, not placebo advice Known limitations
    • Does not generate images for you — this Skill produces workflows, configs, repair logs and scripts; rendering happens in your own ComfyUI
    • VRAM figures are community-tier estimates (±15% spread) that shift with driver/PyTorch/ComfyUI versions; exact values come from your own readings
    • Cannot operate your ComfyUI instance remotely; node edits are executed by you following node-precise steps
    • The custom node ecosystem moves fast; niche node-pack compatibility issues belong in ComfyUI-Manager's issue tracker
    • No LoRA training, no CUDA driver installation, no system-level environment repair What this skill refuses to do
    • No pirated model download links — only official HuggingFace repos, CivitAI and other legitimate sources
    • No cloud API image generation (Midjourney/DALL·E etc.) — that's a different world where you pay per image
    • No invented VRAM numbers — tier ladders and [verify] flags instead; making up digits is lying
    • No pretending hardware limits don't exist — if your card can't run it, it says so, with the nearest feasible alternative attached

    VRAM estimates vary by +/- 15% based on driver/PyTorch versions. Does not support cloud APIs, LoRA training, or OS-level CUDA driver repairs. Requires manual node installation by user.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 3 days ago

    Requires

    1. ComfyUI installed locally (ComfyUI-Manager recommended)
    Python 3.x

    Permissions

    Network Access
    Read Files
    Write Files
    Listed3 days ago

    What's inside

    Frequently Asked Questions

    This skill acts as an automated operations engineer for ComfyUI, specifically designed to prevent 'Out of Memory' (OOM) errors by calculating VRAM budgets and optimizing node structures for consumer-grade GPUs.

    It is compatible with standard local ComfyUI environments and supports major models including SDXL, FLUX.1, and Wan 2.x, with a focus on GGUF and Safetensors formats.

    You receive the specialized logic for VRAM budgeting, OOM triage procedures, and the ability to convert standard UI workflows into optimized API-ready JSON files.

    No, the skill specializes in inference optimization and workflow stability; it does not support local model training, LoRA creation, or fixing low-level OS/CUDA driver issues.

    The skill utilizes a weighted formula to estimate memory usage for models, T5 encoders, and latent space, typically staying within a 15% margin of error based on 8GB VRAM baselines.

    Yes, one of its core features is converting standard ComfyUI workflows into headless API-compatible structures for automated batch processing and seed grids.

    New in Agents & Orchestration