More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    ComfyUI-Agent

    11

    Controls your СomfyUI like an expert

    Free

    2 uses5.0 (5 reviews)
    ComfyUI-Agent

    ComfyUI-Agent

    Example session with this skill installed

    Create a photorealistic image of a futuristic cyberpunk city using Flux, then upscale it by 2x using a model-based upscale node. Check my VRAM first to see if I should use fp8.

    • Read your context and instructions
    • Compiled the comfyui-agent

    I have checked your system environment and found 12GB VRAM available. Based on this, I will use the Flux.1-dev model in fp8 precision to maintain performance and avoid OOM errors. I will wire a standard txt2img graph into a UltimateSDUpscale node using a 4x-UltraSharp model for the 2x pass.

    ComfyUI Generation Plan

    StepActionResource/Node
    1DiscoveryVerified flux1-dev-fp8.safetensors in diffusion_models
    2PromptingApplying Flux-style natural language weighting for the cyberpunk city
    3Graph BuildUNETLoader -> BasicGuider -> SamplerCustomAdvanced
    4UpscaleUpscaleModelLoader -> ImageUpscaleWithModel (2.0x scale)
    5Validationvalidate_graph passed: all links and shapes consistent
    {
      "client_id": "agensi_agent_01",
      "prompt": {
        "3": {
          "class_type": "UNETLoader",
          "inputs": { "unet_name": "flux/flux1-dev-fp8.safetensors" }
        },
        "6": {
          "class_type": "CLIPTextEncode",
          "inputs": { "text": "A futuristic cyberpunk city, neon lighting, rainy streets, cinematic photography, 8k resolution" }
        },
        "10": {
          "class_type": "VAEDecode",
          "inputs": { "samples": ["12", 0], "vae": ["11", 0] }
        },
        "15": {
          "class_type": "ImageUpscaleWithModel",
          "inputs": { "upscale_model": ["16", 0], "image": ["10", 0] }
        },
        "16": {
          "class_type": "UpscaleModelLoader",
          "inputs": { "model_name": "4x-UltraSharp.pth" }
        },
        "17": {
          "class_type": "SaveImage",
          "inputs": { "images": ["15", 0], "filename_prefix": "cyberpunk_upscale" }
        }
      }
    }
    

    Next steps

    • I will execute this graph now. Please monitor the SaveImage output in your workspace folder.
    • If you want to increase the upscale factor to 4x, I recommend switching to a Tiled VAE decode to prevent memory issues.
    • You can provide a reference image if you want to guide the architecture style via an img2img pass.

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

    About this skill

    Manually wiring ComfyUI graphs is error-prone, especially when dealing with mismatched model families, missing custom nodes, or cryptic CUDA OOM errors. This skill provides a structured knowledge base and routing logic for an AI agent to interface directly with a ComfyUI server via MCP. It eliminates guesswork by enforcing runtime discovery of node classes, model paths, and hardware constraints.

    What it does

    • Task routing identifies if a request requires setup, graph building, video generation, 3D pipelines, or debugging.
    • Node discovery uses find_nodes and get_node_info to locate exact class names and widget enums instead of guessing.
    • Workflow wiring provides validated patterns for txt2img, img2img, ControlNet, LoRA chaining, and multi-stage upscaling.
    • Hardware-aware selection picks video models like LTX-2.5, Wan 2.2, or Hunyuan based on specific VRAM and system RAM limits.
    • Error recovery maps server logs to specific fixes for tensor mismatches, missing inputs, and memory exhaustion.

    How it works

    1. Environment check verifies the Comfy MCP server connection and workspace availability.
    2. Runtime discovery lists installed models, custom packs, and assets to ensure all paths exist before execution.
    3. Graph validation runs validate_graph on the generated JSON to catch wiring errors before sending the prompt.
    4. Execution and monitoring triggers the prompt and monitors for specific server-side errors.

    Frameworks & tools

    Built for ComfyUI environments using the Comfy MCP server, comfy-cli, and Python. Supports major model families including SDXL, Flux, Wan, and LTX-Video.

    Why this beats prompting it yourself

    Generic prompts often hallucinate node names or ignore the "class name vs display name" distinction, causing immediate graph failures. This skill enforces a "discover, then build" loop that checks for required custom nodes and validates the graph schema before any execution starts.

    Use cases

    • Automate the conversion of an image into a 3D GLB or Gaussian Splat.
    • Build complex video generation pipelines with synchronized audio and hardware-specific quantization.
    • Troubleshoot and fix "red node" errors or CUDA OOM failures by systematically degrading resolution and batch size.

    Known limitations

    Requires a functional Comfy MCP server installation and workspace configuration. Paid API nodes require manual cost estimation and explicit user approval before execution.

    Requires a running Comfy MCP server. (Agent downloads and starts it himself) Paid API nodes require explicit user confirmation. Does not support non-standard model subfolder structures.

    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

    5.0
    5 reviews
    5
    5
    4
    0
    3
    0
    2
    0
    1
    0

    Trust & safety

    Security scan

    Security scan passed 6 days ago

    • Free with an Agensi account

    Requires

    Comfy MCP
    Python
    Node.js

    Permissions

    Read Files
    Write Files
    Network Access
    Browser
    Terminal / Shell
    Listed9 days ago
    Updated6 days ago

    What's inside

    Frequently Asked Questions

    Prices: Now price is $0, but after special offer ends it will be cost $1.99; Updates: Updates are often and testing on different spaces (Codex, Antigravity, OpenCode, github copilot) and different models (Gemini 3.6 & 3.8 flash, GPT 5.6 luna & terra, GLM 5.3 & flash, deepseek 4.1 flash, minimax m3.1 flash, MiMo v2.6 flash, gemma e4b)

    Agent will install all requriments, such as comfy mcp, comfy cli, python, comfyui

    Yes, the agent is specifically designed for hardware-aware routing. It can detect your system RAM and VRAM limits to intelligently select between high-end models like Flux or Wan 2.1 and more efficient, quantized versions to avoid CUDA OOM errors.

    You receive a structured knowledge base, routing logic, and a suite of validated patterns for common tasks like ControlNet chaining and multi-stage upscaling. It also includes the integration layer needed for the agent to interface with the Comfy MCP server.

    While the skill automates the discovery and wiring of custom nodes, the specific custom node packs must be installed in your ComfyUI environment. The agent will use the `find_nodes` tool to identify what you have available and adapt the workflow accordingly.

    This skill handles complex pipelines including txt2vid (LTX/Hunyuan), image-to-3D (GLB/Gaussian Splatting), and advanced img2img workflows. It effectively manages the multi-stage dependencies required for synchronized audio and sophisticated video upscaling.

    ComfyUI-Agent eliminates graph failures by enforcing a "discover-then-build" loop. It identifies exact node class names, checks available VRAM, and validates JSON schemas before execution to prevent common errors like mismatched model families or "red nodes."

    New in Agents & Orchestration