Agent skill

Comfyui Node Registry

by artokun in artokun/comfyui-mcp

Authoring & publishing ComfyUI custom nodes to the Comfy Registry, covering node structure, pyproject.toml spec, comfy-cli publishing, and CI

MITAuto-check passedAI & LLM Engineering

Install Comfyui Node Registry

skills CLI
$ npx skills add artokun/comfyui-mcp --skill comfyui-node-registry -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install artokun/comfyui-mcp comfyui-node-registry --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/artokun/comfyui-mcp.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugin/skills/comfyui-node-registry .claude/skills/comfyui-node-registry && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
comfyui-node-registry
GitHub stars
800
Token cost
~2.9k tokens
SKILL.md length
942 words
Files
2 (incl. references)
Skills in repo
42
Repo updated
First seen
Licence
MIT

At a glance

Authoring & publishing ComfyUI custom nodes to the Comfy Registry, covering node structure, pyproject.toml spec, comfy-cli publishing, and CI

  • Works in 3 steps: Go to registry.comfy.org and create a… → Your Publisher ID is the value after the… → In the publisher's section, create an…
  • Tasks that involve Diffusion and image models
  • SKILL.md covers Minimal Node Pack Structure, pyproject.toml — Registry…, Registry Setup (one-time) and CLI Publishing Flow, plus 4 more sections
  • Calls pip and npm; reaches github.com and raw.githubusercontent.com; needs REGISTRY_ACCESS_TOKEN

What it does

Comfyui Node Registry is an agent skill from artokun/comfyui-mcp. Authoring & publishing ComfyUI custom nodes to the Comfy Registry, covering node structure, pyproject.toml spec, comfy-cli publishing, and CI

Its SKILL.md is about 2.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files.

It sits in AI & LLM Engineering, covering Diffusion and image models. It works with ComfyUI. The repository describes itself as: Local-first, agent-native control plane for ComfyUI — MCP server + sidebar agent that generates images, video & audio, authors and runs workflows, and edits your live graph in… The licence is MIT.

When your agent uses it

  • Tasks that involve Diffusion and image models

Example prompts

  • “/comfyui-node-registry”

Requirements

  • Python 3
  • Node.js
  • A credential in REGISTRY_ACCESS_TOKEN

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. Go to registry.comfy.org and create a publisher.
  2. Your Publisher ID is the value after the @ on your profile page. It is globally unique and cannot be changed. Use it for PublisherId in…
  3. In the publisher's section, create an API key. Name it and save it somewhere safe. If you lose it you must create a new one; it is not…

What it can do on your machine

Read from SKILL.md and the folder at commit 6ad6fc0. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • pip
    • npm

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • github.com
    • raw.githubusercontent.com

    Also links to:

    • registry.comfy.org

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • REGISTRY_ACCESS_TOKEN

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Comfyui Node Registry loads about 2.9k tokens when it runs, and up to ~3.5k if it reads all its reference files. Until then it costs about 41 tokens; SKILL.md has 942 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~41
When it runs · the whole SKILL.md, loaded when a task matches
~2.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~3.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from artokun/comfyui-mcp at commit 6ad6fc0, republished under its MIT licence (© artokun). 942 words, ~2,866 tokens.

Download SKILL.mdSave it as .claude/skills/comfyui-node-registry/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
comfyui-node-registry
description
Authoring & publishing ComfyUI custom nodes to the Comfy Registry, covering node structure, pyproject.toml spec, comfy-cli publishing, and CI

Authoring & Publishing ComfyUI Custom Nodes

This skill covers writing a ComfyUI custom node pack and publishing it to the Comfy Registry (registry.comfy.org), the public catalog that powers ComfyUI-Manager. For using existing nodes in workflows, see the comfyui-core skill instead.

Minimal Node Pack Structure

A node pack is a Python package placed under ComfyUI/custom_nodes/<name>/. The package __init__.py must export NODE_CLASS_MAPPINGS and NODE_DISPLAY_NAME_MAPPINGS; WEB_DIRECTORY is optional (only if the pack ships frontend JS).

ComfyUI/custom_nodes/my-node-pack/
├── __init__.py          # exports the mappings ComfyUI scans for
├── nodes.py             # node class definitions
├── pyproject.toml       # registry metadata (required to publish)
├── requirements.txt     # optional Python deps
├── .comfyignore         # optional — exclude files from the published archive
├── LICENSE
├── README.md
└── web/js/              # optional frontend extension (see WEB_DIRECTORY)
__init__.py
python
from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS

# Optional: serve frontend JS/CSS from this folder (path relative to __init__.py)
WEB_DIRECTORY = "./web/js"

__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]
A minimal node class (nodes.py)
python
class ImageSelector:
    CATEGORY = "example"          # menu path where the node appears

    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "images": ("IMAGE",),
                "mode": (["brightest", "reddest", "greenest", "bluest"],),
            },
            "optional": {
                "threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
                "count": ("INT", {"default": 1, "min": 1, "max": 64}),
                "label": ("STRING", {"default": "", "multiline": False}),
            },
        }

    RETURN_TYPES = ("IMAGE",)        # tuple of output data types
    RETURN_NAMES = ("image",)        # optional friendly output names
    FUNCTION = "choose_image"        # name of the method ComfyUI calls
    OUTPUT_NODE = False              # True for terminal nodes (e.g. SaveImage)

    def choose_image(self, images, mode, threshold=0.5, count=1, label=""):
        import torch
        brightness = [torch.mean(img.flatten()).item() for img in images]
        best = brightness.index(max(brightness))
        return (images[best].unsqueeze(0),)   # MUST return a tuple


NODE_CLASS_MAPPINGS = {
    "ImageSelector": ImageSelector,        # globally unique class_type key
}

NODE_DISPLAY_NAME_MAPPINGS = {
    "ImageSelector": "Image Selector",     # label shown in the UI
}
Node class contract
MemberRequiredPurpose
INPUT_TYPESyes@classmethod returning {"required": {...}, "optional": {...}}. Each input is (TYPE,) or (TYPE, {opts}).
RETURN_TYPESyesTuple of output type strings (e.g. ("IMAGE", "MASK")). Single output still needs a trailing comma.
FUNCTIONyesString name of the method to execute.
CATEGORYyesMenu path string for the Add Node menu.
RETURN_NAMESnoFriendly names for outputs (defaults to lowercased types).
OUTPUT_NODEnoTrue marks a terminal node that produces a result (save/preview).

The options dict drives the UI widget for each input type:

  • ("INT", {"default": 0, "min": 0, "max": 100, "step": 1})
  • ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.1})
  • ("STRING", {"default": "", "multiline": True})
  • (["a", "b", "c"],), a literal list, becomes a dropdown
  • ("IMAGE",), ("LATENT",), ("MODEL",) etc. are typed connections (no widget)

The executing method must return a tuple matching RETURN_TYPES, even for a single output (return (result,)).

pyproject.toml — Registry Metadata

Required to publish. comfy node init scaffolds this file. See references/pyproject.toml for a fully-commented example.

toml
[project]
name = "my-node-pack"                          # unique & IMMUTABLE; lowercase, <100 chars, no "ComfyUI" prefix
description = "What this node pack does"
version = "1.0.0"                              # semantic version X.Y.Z — bump to publish a new version
license = { file = "LICENSE" }                 # or { text = "MIT License" }
requires-python = ">=3.10"
dependencies = [
    "comfyui-frontend-package<=1.21.6",        # optional — pin frontend if you ship UI
]
classifiers = [
    "Operating System :: OS Independent",
]

[project.urls]
Repository = "https://github.com/you/my-node-pack"   # REQUIRED — must be a valid repo URL
Documentation = "https://github.com/you/my-node-pack/wiki"
"Bug Tracker" = "https://github.com/you/my-node-pack/issues"

[tool.comfy]
PublisherId = "your-publisher-id"              # the id after @ on your registry profile
DisplayName = "My Node Pack"                   # human-friendly name in the registry
Icon = "https://raw.githubusercontent.com/you/my-node-pack/main/icon.png"   # square, max 400x400px
requires-comfyui = ">=1.0.0"                   # optional ComfyUI version constraint
Field rules (verified against the live spec)
FieldSectionNotes
name[project]Unique and immutable once published. <100 chars; alphanumeric + - _ .; no consecutive special chars; can't start with a number/special char; case-insensitive. Don't prefix with "ComfyUI".
version[project]Semantic X.Y.Z — X breaking, Y backwards-compatible feature, Z bug fix. Each value is published once and is immutable.
description[project]Short summary (recommended).
license[project]{ file = "LICENSE" } or { text = "MIT License" }.
requires-python[project]e.g. ">=3.10" (recommended).
dependencies[project]PEP 508 requirement strings; can pin comfyui-frontend-package.
Repository[project.urls]Required — valid GitHub repo URL.
PublisherId[tool.comfy]Required — your publisher id (after the @ on your profile).
DisplayName[tool.comfy]Friendly registry name (optional).
Icon[tool.comfy]URL to a square image, max 400×400px; SVG/PNG/JPG/GIF.
Banner[tool.comfy]URL to a 21:9 banner image; SVG/PNG/JPG/GIF (optional).
requires-comfyui[tool.comfy]ComfyUI version range using < > <= >= ~= != (optional).
includes[tool.comfy]Array forcing extra folders into the published archive.
Controlling the published archive
  • .comfyignore uses .gitignore syntax; files listed are excluded from the published archive. Use it to drop tests, examples, large assets, and dev files.
  • [tool.comfy].includes is the inverse: it force-includes folders that would otherwise be skipped (e.g. a bundled web/dist).

Registry Setup (one-time)

  1. Go to registry.comfy.org and create a publisher.
  2. Your Publisher ID is the value after the @ on your profile page. It is globally unique and cannot be changed. Use it for PublisherId in pyproject.toml.
  3. In the publisher's section, create an API key. Name it and save it somewhere safe. If you lose it you must create a new one; it is not recoverable.

CLI Publishing Flow

Install comfy-cli (requires Python 3.10+; a virtualenv is recommended):

bash
pip install comfy-cli
CommandWhat it does
comfy node initScaffolds pyproject.toml with registry metadata in the current node pack folder. Fill in the required fields (esp. PublisherId and Repository).
comfy node publishValidates and uploads the current version to the registry. Prompts for your API key. Prints the registry URL on success.

Versions are immutable. Once a version is published it cannot be modified or overwritten. To ship changes, bump version and publish again. To pull a bad version, deprecate it on the website (More Actions > Deprecate), which prompts users to upgrade rather than deleting it.

Show full SKILL.md (343 more words)Show less

CI Publishing (GitHub Actions)

Automate publishing on every version bump. Add the API key as a repo secret named REGISTRY_ACCESS_TOKEN (Settings > Secrets and variables > Actions), then create .github/workflows/publish_action.yml:

yaml
name: Publish to Comfy registry
on:
  workflow_dispatch:
  push:
    branches:
      - main
    paths:
      - "pyproject.toml"

jobs:
  publish-node:
    name: Publish Custom Node to registry
    runs-on: ubuntu-latest
    steps:
      - name: Check out code
        uses: actions/checkout@v4
      - name: Publish Custom Node
        uses: Comfy-Org/publish-node-action@main
        with:
          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}
  • Triggers on push to main but only when pyproject.toml changes (i.e. when you bump version). workflow_dispatch allows manual runs.
  • If your default branch isn't main, update the branches: list.
  • The action reads the version from pyproject.toml and publishes it, so the typical flow is bump version, commit, push to main, done.

Optional Frontend Extension

If your pack adds custom UI (widgets, sidebar tabs, menu items), set WEB_DIRECTORY in __init__.py and ship JS there. New frontend extensions should target the modern @comfyorg/extension-api rather than poking at legacy globals; pull in @comfyorg/comfyui-frontend-types for TypeScript types (npm install -D @comfyorg/comfyui-frontend-types). For the full frontend authoring workflow (defineExtension/defineNode/defineWidget and the defineSidebarTab/defineCommand/defineSetting shell APIs), see the sibling comfyui-frontend-extensions skill.

Common Mistakes

  1. Forgetting the return tuple. The FUNCTION method must return (value,), not return value, even for one output.
  2. Single-element RETURN_TYPES without a comma. ("IMAGE") is a string, not a tuple. Write ("IMAGE",).
  3. INPUT_TYPES not a @classmethod. ComfyUI calls it on the class; missing the decorator breaks node loading.
  4. Trying to overwrite a published version. Versions are immutable. Bump version instead; deprecate bad ones on the website.
  5. Renaming name after publishing. It's immutable and globally unique. Pick a good name (no "ComfyUI" prefix) up front.
  6. Missing [project.urls].Repository. It's required; publishing fails without a valid repo URL.
  7. Wrong PublisherId. Use the id after the @ on your profile, not your display name.
  8. Oversized icon. Must be square and ≤ 400×400px; larger images are rejected.
  9. Renaming class keys in NODE_CLASS_MAPPINGS. The key is the class_type stored in workflow JSON. Changing it breaks every saved workflow that used the node.
  10. Committing the API key. Store it as the REGISTRY_ACCESS_TOKEN secret; never in pyproject.toml or the repo.

Sources

  • Official: Comfy Registry at https://registry.comfy.org and comfy-cli publishing docs used by comfy node publish.
  • Empirical: field-rule notes verified against the live spec; common-mistakes list is from observed publish failures.

© artokun, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (references) in plugin/skills/comfyui-node-registry of artokun/comfyui-mcp.

  • SKILL.md
  • references/pyproject.toml

Open the folder on GitHubat commit 6ad6fc0

Compare with similar skills

Comfyui Node Registry next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Comfyui Node Registry compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Comfyui Node Registry this skillartokun/comfyui-mcp800—~2.9kAutomated safety check: PassMIT
Comfyui AnimatoolShiroEirin/comfyui-good-anima481—~4.6kAutomated safety check: PassGPL-3.0
Comfyui Agent Skill MieMieMieeeee/comfyui-agent-skill116—~3.9kAutomated safety check: PassApache-2.0
Importing SubgraphsComfy-Org/workflow_templates1.3k—~1.5kAutomated safety check: PassMIT
Comfyui Node Addernixified-ai/flake841—~806Automated safety check: PassAGPL-3.0
Managing BundlesComfy-Org/workflow_templates1.3k—~1.2kAutomated safety check: PassMIT

Similar skills

  • Comfyui Animatool

    ShiroEirin/comfyui-good-anima

    Route ALL Anima image generation: validate Danbooru hard anchors, form visual brief, assemble English prompts and args, then load comfyui-manager for workflow execution.

    481 GitHub stars~4.6k tokensUpdated 3 mo ago
    AI & LLM EngineeringAuto-check passed
  • Comfyui Agent Skill Mie

    MieMieeeee/comfyui-agent-skill

    Agent skill for running registered ComfyUI workflows through a stable CLI, and for importing a user's own ComfyUI workflow into their private registry after review.

    116 GitHub stars~3.9k tokensUpdated 5 days ago
    AI & LLM EngineeringAuto-check passed
  • Importing Subgraphs

    Comfy-Org/workflow_templates

    Imports and registers subgraph blueprints into the ComfyUI workflowtemplates repository.

    1.3k GitHub stars~1.5k tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Comfyui Node Adder

    nixified-ai/flake

    Adds new custom nodes to the ComfyUI Nix project, including npins fetching, dependency resolution in package.nix, disabling impure pip installs, and verifying the Nix build.

    841 GitHub stars~806 tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Managing Bundles

    Comfy-Org/workflow_templates

    Manages template bundles, categories, and ordering in the ComfyUI template repository.

    1.3k GitHub stars~1.2k tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Headroom

    momori777/Artemis

    SmartCrusher + CCR context compression — crunch large JSON arrays, tool outputs, and search results to save tokens.

    378 GitHub stars~562 tokensUpdated 9 days ago
    AI & LLM EngineeringAuto-check passed

More from artokun/comfyui-mcp

All 42 skills in this repo
  • AI Toolkit Trainer

    artokun/comfyui-mcp

    Train custom LoRAs with ostris AI-Toolkit. An agent skill from artokun/comfyui-mcp.

    800 GitHub stars~2.7k tokensUpdated 4 days ago
    Auto-check passed
  • Anima Base

    artokun/comfyui-mcp

    Anime/illustration text-to-image (ANIMA 1.0, ~2B Cosmos DiT).

    800 GitHub stars~4k tokensUpdated 4 days ago
    Auto-check passed
  • Civitai

    artokun/comfyui-mcp

    Discover Civitai models with the BUILT-IN downloadmodel action:"searchcivitai" and install/generate them locally.

    800 GitHub stars~1.1k tokensUpdated 4 days ago
    Auto-check passed
  • Color Correction

    artokun/comfyui-mcp

    Diagnose and fix video/image color OBJECTIVELY with the getimage (action:"analyzecolor") tool (scopes/stats such as black/white points, contrast, saturation, clipping, cast) instead of eyeballing a…

    800 GitHub stars~2.4k tokensUpdated 4 days ago
    Auto-check passed
  • Comfyui Frontend Extensions

    artokun/comfyui-mcp

    Authoring ComfyUI v2 frontend extensions with @comfyorg/extension-api, covering defineNode/defineExtension/defineWidget, shell UI (sidebar tabs, commands, hotkeys), typed events, and handles.

    800 GitHub stars~5.4k tokensUpdated 4 days ago
    Auto-check passed
  • Comfyui Launch Flags

    artokun/comfyui-mcp

    Pick the right ComfyUI startup flags for VRAM, attention, caching, and speed.

    800 GitHub stars~3.1k tokensUpdated 4 days ago
    Auto-check passed

Works with

Questions about Comfyui Node Registry

What does Comfyui Node Registry do?

Authoring & publishing ComfyUI custom nodes to the Comfy Registry, covering node structure, pyproject.toml spec, comfy-cli publishing, and CI. Comfyui Node Registry is an agent skill from artokun/comfyui-mcp.

When should I use Comfyui Node Registry?

Comfyui Node Registry fits situations like: tasks that involve Diffusion and image models.

How do I install Comfyui Node Registry in Claude Code?

Run `npx skills add artokun/comfyui-mcp --skill comfyui-node-registry -a claude-code`. Or copy the skill folder (plugin/skills/comfyui-node-registry in artokun/comfyui-mcp) into .claude/skills/comfyui-node-registry in your project. Claude Code loads it when a task matches its description.

How do I install Comfyui Node Registry in Codex?

Run `npx skills add artokun/comfyui-mcp --skill comfyui-node-registry -a codex`. Or copy the skill folder (plugin/skills/comfyui-node-registry in artokun/comfyui-mcp) into .agents/skills/comfyui-node-registry in your project. Codex loads it when a task matches its description.

Can I use Comfyui Node Registry in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add artokun/comfyui-mcp --skill comfyui-node-registry -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/comfyui-node-registry, .gemini/skills/comfyui-node-registry, .github/skills/comfyui-node-registry and .opencode/skills/comfyui-node-registry in your project.

What does Comfyui Node Registry need to run?

Going by SKILL.md and its folder, Comfyui Node Registry needs the command-line tools its instructions call (pip and npm) and credentials named REGISTRY_ACCESS_TOKEN. Our summary lists: Python 3; Node.js; A credential in REGISTRY_ACCESS_TOKEN.

Does Comfyui Node Registry access the network?

SKILL.md names 3 domains. In commands or code: github.com and raw.githubusercontent.com; the agent is likely to contact these when it follows the instructions. As links in the text: registry.comfy.org. This is read from the text; nothing was executed.

Is Comfyui Node Registry safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Comfyui Node Registry use?

Comfyui Node Registry is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Comfyui Node Registry use?

About 2.9k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 639 tokens, read only when the agent opens those files.

What are the alternatives to Comfyui Node Registry?

Skills that share tags, products or a category with Comfyui Node Registry: Comfyui Animatool (ShiroEirin/comfyui-good-anima, 481 stars), Comfyui Agent Skill Mie (MieMieeeee/comfyui-agent-skill, 116 stars), Importing Subgraphs (Comfy-Org/workflow_templates, 1.3k stars) and Comfyui Node Adder (nixified-ai/flake, 841 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Comfyui Node Registry?

artokun (a GitHub user) maintains it in artokun/comfyui-mcp, which has 800 GitHub stars. The repository holds 42 skills in this directory. The repository was last updated on October 5, 2026.

Source: artokun/comfyui-mcp on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.