Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    ComfyUI Media Engine pro

    1

    Automate ComfyUI installation, custom node management, and API-driven media generation pipelines.

    $5.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    ComfyUI Media Engine pro

    ComfyUI Media Engine pro

    Example session with this skill installed

    I need to set up ComfyUI on Ubuntu with a 3090. I want to generate a short video using AnimateDiff via the API. Give me the setup commands and a basic API script.

    • Read your context and instructions
    • Compiled the comfyui media engine

    I have outlined the environment setup for Ubuntu and a basic API automation script for your RTX 3090.

    Environment & Assumptions

    • OS: Ubuntu (22.04/24.04 recommended)
    • Hardware: NVIDIA RTX 3090 (24GB VRAM)
    • Drivers: CUDA 12.1+ expected
    • Target: AnimateDiff video pipeline via API

    Setup or Launch Steps

    
    # Create isolated environment
    python3 -m venv comfy_env
    source comfy_env/bin/activate
    
    # Install PyTorch with CUDA 12.1 support
    pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
    
    # Clone and install ComfyUI
    git clone https://github.com/comfyanonymous/ComfyUI.git
    cd ComfyUI
    pip install -r requirements.txt
    
    # Install Manager for node handling
    cd custom_nodes
    git clone https://github.com/ltdrdata/ComfyUI-Manager.git
    cd ..
    

    API Automation

    import json
    import urllib.request
    
    def queue_prompt(prompt):
        p = {"prompt": prompt}
        data = json.dumps(p).encode('utf-8')
        req = urllib.request.Request("http://127.0.0.1:8188/prompt", data=data)
        return urllib.request.urlopen(req).read()
    
    # Note: Replace 'nodes' with your specific AnimateDiff workflow IDs
    workflow_api = {
        "3": {
            "inputs": { "seed": 42, "steps": 20, "cfg": 8, "sampler_name": "euler", "model": ["4", 0] },
            "class_type": "KSampler"
        },
        "4": {
            "inputs": { "ckpt_name": "sd15/v1-5-pruned.ckpt" },
            "class_type": "CheckpointLoaderSimple"
        }
    }
    
    response = queue_prompt(workflow_api)
    print(f"Prompt queued: {response}")
    

    Next steps

    1. Download the AnimateDiff motion module to models/animatediff_models/.
    2. Launch the server using python main.py --listen to verify API accessibility.
    3. Export your specific AnimateDiff workflow as "API Format JSON" from the UI to update the script.

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

    About this skill

    Managing ComfyUI manually involves a complex web of Python dependencies, CUDA compatibility issues, and fragmented custom node ecosystems. This skill provides a structured approach to installing, configuring, and automating ComfyUI media pipelines without the trial-and-error usually associated with local AI generation.

    What it does

    • Environment management identifies hardware, VRAM, and driver compatibility to ensure stable installation.
    • Workflow construction generates valid API and UI JSON structures using actual node class names and input keys.
    • Dependency orchestration handles custom node installation and Python package conflicts systematically.
    • API automation scripts the generation process for image, video, and audio tasks via server endpoints.
    • Diagnostic troubleshooting classifies errors from CUDA crashes to missing checkpoints with specific rollback steps.

    How it works

    1. Discovery scans the operating system and existing installation to map available hardware and paths.
    2. Configuration guides the setup of specific model families, VAEs, and required custom nodes.
    3. Validation checks JSON workflow syntax and node availability before execution.
    4. Execution manages the generation queue and retrieves media outputs from the server.

    Frameworks & tools

    This skill works with ComfyUI, PyTorch, CUDA, and standard Python environments (venv/Conda). It supports diverse media pipelines including Stable Diffusion, AnimateDiff, and audio generation models.

    Why this beats prompting it yourself

    Generic prompts often hallucinate node names or ignore VRAM limits, leading to broken JSON and CUDA out-of-memory errors. This tool follows a strict discovery-first protocol to ensure instructions match your specific hardware and software version.

    Use cases

    • Set up a headless ComfyUI server on a remote Linux instance with custom models.
    • Build a Python script to batch-generate videos using the ComfyUI API.
    • Debug a failing workflow caused by conflicting custom node versions or missing VAEs.
    • Create complex multi-modal JSON pipelines that link image, motion, and audio nodes.

    Known limitations

    Does not bypass model license agreements or provide hardware performance guarantees. Generation capabilities are strictly limited by your local GPU, disk space, and installed model files.

    Requires existing hardware drivers. Does not bypass model licenses. Capabilities depend on local GPU/VRAM and installed node versions.

    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 1 month ago

    Requires

    Python

    Permissions

    No special permissions declared or detected

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill automates the technical heavy lifting of ComfyUI, including environment setup, hardware-aware configuration, and the creation of valid API-driven workflows to prevent CUDA errors and broken JSON.

    The skill is designed for use with advanced LLMs and AI agents capable of executing Python scripts, managing local file systems, and interacting with REST APIs.

    Yes, it includes specialized logic for identifying and resolving Python dependency conflicts and missing custom node requirements that often break complex media pipelines.

    You receive the specialized skill logic for environment discovery, workflow validation, and API orchestration, along with documentation for integrating it into your agent's toolkit.

    While the skill handles the logic and orchestration, you must provide your own hardware (NVIDIA GPU recommended) and download the specific model checkpoints (e.g., SDXL, AnimateDiff) you wish to use.

    The Media Engine is built to be version-agnostic by using a discovery-first protocol that maps the actual node classes available in your specific installation rather than relying on hardcoded names.

    New in Workflow Automation