Generating with ComfyUI

ComfyUI is connected through the ComfyUI plugin that ships with Mosael: it is already on the Plugins page, with nothing to install from the market and no API key to paste. One ComfyUI server is one connection, and it brings two things:

• Models: every workflow saved on it shows up as a model in the model pickers of AI Studio, boards and the workflow “AI generate” node, next to every other provider's models;
• Tools: every workflow is also a tool (“Workflow · name”) whose inputs are that graph's own prompts, loader nodes and tunable parameters, returning every output; plus listing workflows and model files, checking the GPU and queue, importing outputs from ComfyUI's history into the asset library, and interrupt / clear the queue / free VRAM. The agent can call them directly, and each tool is a node in the workflow node panel.
• Two libraries: Open model library on the connection's title row shows every model file on the server and downloads missing ones; Open workflow library shows, manages and imports the workflows saved on it, installing missing node packs through ComfyUI-Manager.
• Workbench (desktop app): opens this ComfyUI's own canvas full screen in Mosael, with Mosael's model, missing-items, app and run panels beside it (see below).

Connecting a ComfyUI server#

1. Start ComfyUI (on this machine it listens on http://127.0.0.1:8188 by default).
2. Open Plugins → ComfyUI → “New connection”, keep Connect to a server under “Where it runs” (the default) and fill in the Server URL. A LAN address (such as http://192.168.1.20:8188) uses another machine's GPU. If ComfyUI sits behind a reverse proxy with login or ComfyUI-Login, enter user:password or a token as the Access credential (the former is sent as Basic auth, the latter as a Bearer token); don't put a user name and password in the URL.
3. Grant the permissions it asks for and switch the connection on: network:comfyui (talk to this ComfyUI), network:huggingface, network:civitai and network:modelscope (the model library looks up links and downloads models from these sites), network:github, network:pypi and network:pytorch (when Mosael installs ComfyUI on this computer it downloads the source, dependencies and PyTorch; see the next section), network:comfy-registry (the workbench Assistant looks up node packs on the official Comfy registry, read only), and filesystem:write (when ComfyUI runs on this computer, downloaded models are written into its models folder). These are exactly the things the plugin does; connections carried over from an earlier version are switched off until you grant the new ones (see the upgrade section at the end).

Mosael then asks the server which workflows it has. The “Workflows for generation” row on the connection card shows “N workflows · refreshed just now”; View workflows lists whether each workflow (and each of its forms) makes images or videos, which kinds of generation it supports, which inputs it takes and which parameters it has. When the server can't be reached the row says only what to do ("Can't reach this ComfyUI. Make sure it is running and the URL is right"), with the address and the raw error in the hover hint; if the last list is still there, the row and the top of the list both say which refresh it is from, the list is dimmed, and Reconnect tries again. Create one connection per server; each brings its own models and tools, and with several they fold into one line each (see Plugins).

Under Settings → AI image / AI video, a ComfyUI connection is shown as “Provided by a plugin”: rename it or change its URL on the Plugins page. Its models can be set as default models like any other.

Running ComfyUI on this computer#

The “New connection” dialog starts with Where it runs, which has three options: connect to a server that's already running (as above), Use my own install, or Let Mosael install it; you can switch later on the connection card. With the last two Mosael starts and stops it for you: it starts when it's used (a generation, opening the model library or the workbench) and stops when you quit Mosael. There's no server URL to fill in: Mosael picks a free port from 8189 upwards and makes it the connection's server URL. Only a deployment admin can pick these two (others see them greyed out), and the confirmation names the machine the code runs on. The dialog lists the permissions the plugin asks for and grants them when the connection is created: right away Mosael asks the plugin to check the folder or plan the install, and without them it does nothing for this connection.

• Use my own install: enter the folder of an installed ComfyUI (for the Windows portable build either the outer or the inner folder works; in the desktop app, Choose… next to it opens the system dialog) and leave the interpreter empty to let the plugin find it. Add asks once to confirm that Mosael will run the code in this folder; right after the connection is created Mosael runs a quick trial, and the new connection opens showing the ComfyUI version, PyTorch, GPU and anything missing. If the folder isn't recognised the problems are marked in red; choose Change to pick another. Switching an existing connection to this option on its card saves it only if it can start. ComfyUI-Manager has to be the pip version (V4, built into recent ComfyUI): if it's installed, it's turned on with ComfyUI. Mosael doesn't support the old Manager cloned into custom_nodes; the check warns about it and gives the command to switch to the pip version (pip install -r manager_requirements.txt).
• Let Mosael install it: no folder to choose (it installs into Mosael's data folder, one copy per connection). The new connection opens on the install plan, and nothing is installed until you choose Install — the plan says whether this machine can install it (Macs with Apple silicon; Windows or a Linux server (x86_64) with an NVIDIA GPU; other systems aren't supported in this version, and it says why), which PyTorch, how much disk space at least (5 GB on a Mac, 8 GB on Windows and Linux), the steps, where it downloads from and through which proxy. After you confirm, Mosael downloads a pinned ComfyUI release, creates its own Python environment, installs PyTorch, the dependencies, ComfyUI-Manager and pysssss, and starts it once at the end. While it installs you see the step, the file being downloaded and the speed; you can cancel, and Resume continues from the first unfinished step. A fresh install takes 4–5 minutes on an Apple silicon Mac and uses about 2 GB. No models are downloaded: once it's installed, choose Open model library and pick the ones you need.
• On a slow network, switch the pip source under Admin → Engines → Download sources; on Windows pick a PyTorch source mirror for the CUDA build of PyTorch, and if GitHub is slow set a GitHub mirror prefix (the archives are checked by sha256, so a mirror can't change their content). Downloads use the proxy from Settings → Network.
• When a Mosael update ships a different Python version, the connection card says the environment needs a rebuild; one click reinstalls only the Python environment, leaving the source and models alone.
• Linux servers: an NVIDIA GPU with its proprietary driver (nvidia-smi works; in a container, pass the GPU in, for example docker run --gpus all), x86_64, and glibc 2.28 or newer (CentOS 7 is too old). The driver is chosen per GPU just as on Windows; Linux driver version numbers simply have their own column.
• Shared models folders: if you already have models (another ComfyUI's models, an A1111 / Forge webui folder), add the folder under Shared models folders on the card instead of copying it. It's added only if it's recognised and takes effect after a restart; the card shows what it was recognised as, whether it's loaded and how many models it sees. Mosael only reads these folders — new downloads from the model library still go into its own models, and no preview images are written into a shared folder; the configuration lives in Mosael's data folder, not in your ComfyUI folder.
• Stop when idle: unless it's set to keep running, it stops after 30 minutes without use (change it under Advanced; 0 = never) to free GPU memory, and starts again the next time it's used. It doesn't stop while jobs are running or queued; an open workbench counts as use.
• Update and go back (the copy Mosael installed): the Version row on the card says which version is installed and offers “Update to …” when a newer pinned version exists. An update stops it, switches to the new source and dependencies and starts it once — if any step fails or it won't start, it goes back to the earlier version automatically; after a successful update you can go back to the earlier version without downloading it again. Models, custom nodes, workflows and settings come along.
• Deleting: when you delete the connection you can delete the copy Mosael installed too and keep the models (moved to local-services/kept-models in the data folder, ready to add back as a shared models folder); otherwise it stays on disk. A folder you picked with Use my own install is never deleted.

Saved workflows are models#

Save a workflow in ComfyUI (into its workflows folder) and it appears in the pickers within a minute — Mosael checks once a minute whether the workflows folder changed and only re-reads it when it did; click Refresh workflows on the Plugins page if you can't wait. The model is named after the workflow, and its output nodes decide what it makes: a workflow with a video combine node (VHS Video Combine, Save Video …) is a video model, everything else is an image model. A workflow that only outputs text is not a model (taggers, prompt interrogators — their only output node is a Show Text kind): it can't hand back an image, so picking it would never produce one. It is still a tool (see below), usable in workflows and on boards.

One more model may appear: Built-in text-to-image, when at least one checkpoint model is installed in ComfyUI — it works even with no saved workflows.

A workflow deleted in ComfyUI disappears from the pickers too.

Parameters and inputs#

Mosael reads what each workflow lets you tune and what it takes:

In the workflow	In Mosael
The prompt nodes upstream of the sampler / guider	Prompt and negative prompt
With no sampler Mosael knows (API nodes such as MiniMax / Hailuo, Kling and Veo; packs with their own sampler such as WanVideo; MiniMax H3 wrapped in a subgraph): a multiline prompt on a node wired into an output	Prompt; a negative_prompt on the same node is the negative prompt
The sampler's seed, RandomNoise's noise_seed	Seed (random each time when left empty)
Width and height of the node that creates the canvas (EmptyLatentImage, Wan / Hunyuan video latents)	Size: the workflow's own when not chosen; the list holds the workflow's own and a few common sizes, and you can also type any "width x height" (such as 768x1024), each side rounded to a multiple of 8, at least 16
The canvas node's batch_size	How many images one run makes, as the workflow is saved: a saved 4 makes 4 per run
An image workflow with a seed (with or without a canvas)	“Runs” (up to 4, one when not chosen): the plugin runs once to the end before submitting the next run, each run as the workflow is saved with a new seed (counting up from the seed you gave), and each output's seed is kept in its generation parameters; what comes back is runs × images per run, and the field says how many per run and in total. Cancelling stops the rest from being submitted; if one run fails, the others are still returned with a note such as "2 of 3 runs came out; run 2 failed because …". Upscaling and others without a seed would make the same image every run, so they have no such field
The save nodes of that kind (the preview nodes when nothing is saved)	How many files one run returns, so that many placeholders are laid out up front. With more than one, the parameters gain Results from: pick one node to get only its output while the other save nodes don't run. It defaults to all; when the workflow only has preview nodes and some of them are not the final result (the first pass of a two-pass workflow, the image before a face detailer or an upscale, a ControlNet control image, a mask), it defaults to Final result, so only the last result node comes back. Pick All to get every one. A preview node that only shows the loaded image or a preprocessor's result (an OpenPose skeleton, Canny lines, a depth map) is not an output
Checkpoint, LoRA, VAE, text encoder, upscale model and ControlNet loaders	Drop-downs listing the files installed in ComfyUI, each with a thumbnail, base model and trigger words (see "The model library shows up when generating" below)
Steps, CFG, sampler, scheduler, denoise, frame count …	One entry each in the parameters panel with a plain name (“Steps”, “Sampler”); common ones first, details under Advanced
LoadImage nodes	Reference images; in video workflows the ones wired to start_image / end_image are the first / last frame (also when they pass through a resize, crop or similar step first); an image-to-video workflow requires its first frame. With several loader nodes (or named ones), each slot carries its node's name in order
LoadImageMask, or a LoadImage whose only used output is its mask (alpha)	Mask (inpainting — white is the area to change)
LoadVideo / VHS_LoadVideo	Video to edit (video-to-video)
LoadAudio	Driving audio (in video workflows) or reference audio

Only the part of the graph ComfyUI will actually run counts: the nodes that reach an output and everything upstream of them. A dangling canvas node doesn't turn into Size or Images, a loader whose downstream is entirely bypassed doesn't become an input, and a preview cut off upstream isn't counted among the outputs; rgthree's front-end-only nodes such as Relay and Repeater stay out of the graph, and the fixed seed stored in its Seed node is no longer replaced on every run.

What is missing is said in full before anything is submitted. Mosael first checks the graph against this ComfyUI's nodes and model files: nodes that aren't installed and model files picked in loaders that aren't on the machine are listed together, with where to install them or what to swap, and nothing is submitted — no installing one only to discover the next. When some outputs fail validation (the face-fix or upscale branch needs a missing model, say), ComfyUI would still queue the rest; Mosael cancels that task and says why instead of handing back a preview as the result.

When a workflow has two nodes of the same kind (two KSamplers, say), the parameter names say which is which: the node title if you gave it one, otherwise “KSampler #2”. Hover a parameter name to see which node and input it comes from. Inputs that only matter on the ComfyUI side, such as the filename prefix, are not listed.

Anything you leave untouched in the parameters panel is not sent, so the workflow keeps its own value. Inputs are uploaded to ComfyUI's input folder first and then wired into the matching node — you just pick from your asset library. Workflows without a prompt (upscale, background removal) require their image — otherwise ComfyUI would run the example image saved in the workflow — and only offer “image to image”.

Whether a prompt is needed is read from the workflow too. A workflow with no text feeding its sampler (upscale, background removal, face restore, frame interpolation) takes no prompt: AI Studio, boards and workflow nodes show no prompt box, and attaching the input is enough. If the prompt node already holds a sentence, the prompt is optional (empty keeps the workflow's own); if it is empty, or the pasted template has {{prompt}}, you need to write one.

Prompt optimization follows the workflow: SD 1.5 / SDXL workflows get comma-separated English tags plus a negative prompt; Flux-style workflows keep natural language.

Tools: ComfyUI for the agent and for workflows#

One tool per workflow. Every workflow saved in ComfyUI (plus the built-in text-to-image) shows up as “Workflow · name” in the tool list, the workflow node panel and the agent's tools, with a form made from that graph. A workflow with a simplified form has two: the full workflow (named after the file) and the form (named after its title), with a second line saying “From” plus the workflow’s name, or “Full workflow”; searching by either name finds them, and renaming the title changes only the name, not the nodes that use it:

• prompt and negative prompt (empty keeps the workflow's own);
• one field per loader node — “Image”, “Mask”, “Video”, “Audio” — listing only that kind of asset, with the node's title when you gave it one;
• one field per tunable parameter, named and ranged as in the generation parameters, common ones first; seed, size and runs under Advanced — one run when left empty, each run making what the batch_size saved on the workflow's canvas makes, and size takes any width and height, as in generation;
• outputs per output node: connect “Image · SaveImage” downstream directly, or use “First output” / “All outputs” / “Text outputs” / “Summary” / “Task id”. Those five are for wiring workflows: run it on a board and only each output node's own product (image, video, audio, text) lands to the right — no duplicate image, no JSON or summary notes. When an output node makes several files at once (batch_size 2, several runs), its output carries all of them, and the node, “This run” and the board show them all; a next step that takes one image connects “First output”, or goes in a “Loop · for each” to take every one.

Renaming or moving a workflow in ComfyUI keeps the same tool (ComfyUI stores the workflow's id in the file); files saved by a very old ComfyUI have no id, so a rename makes them a different tool — open and save one in a current ComfyUI and it gets an id; saved nodes move to the new tool name automatically. A copy made outside ComfyUI carries the same id as the original, so both are then named by their path (the copy never takes over the original's tool).

There used to be a generic “Run workflow by id” tool as well: it didn't know which workflow it would run, yet its form asked you for parameters. It is gone — everything it could run now has its own tool. Workflow nodes and board items that used it with a particular graph are rewritten to that graph's own tool automatically (incoming data edges and board bindings too; values keyed by node id or by node title both carry over); fields the new tool has no place for are dropped, and the workflow revision's note lists them. Nodes whose graph has since been deleted in ComfyUI are left as they are and the run check reports an unknown node type; pick another one.

Without a seed the workflow's own setting applies: a seed set to “randomize” changes every run, a “fixed” one is kept.

Of the other tools, the five in bold are on by default:

Tool	What it does
List workflows (read-only)	What each workflow takes (which node loads which kind of asset), what it lets you tune, what it outputs, what it seems to do (upscale, inpaint, background removal, face restore, frame interpolation …), and which tool runs it
Import ComfyUI outputs	Imports outputs from ComfyUI's history by task id (or the most recent runs) into the asset library — including things run directly in the ComfyUI interface
Server status (read-only)	ComfyUI version, GPU and free VRAM, running / queued task counts
List model files (read-only)	Installed checkpoints, LoRAs, VAEs, upscale models, ControlNets …
Interrupt	Stops the running task; with a task id only that one, leaving other people's tasks alone
Clear queue	Clears every queued task (including other people's on the same server); off by default
Free VRAM	Unloads models and frees VRAM; off by default

Which one? A workflow's own tool is the easiest (its inputs are its own). For a prompt that should turn into an image or a video, use the models (generation): they get progress in the task center, cancel, resume after a restart and usage records, and a run may last 6 hours. To run a processing workflow as-is (upscale, background removal, inpainting, face restore, frame interpolation), feed it several inputs at once, or get every intermediate output back, use that workflow's tool.

On a board a workflow has one entry: Generate. A workflow that delivers images, video or audio (preview nodes such as PreviewImage don't count — they write temporary files) is the same thing as the model of the same name: the board no longer lists its tool, and the "⋯" at the top of an item doesn't repeat it — add an image (video, audio) item and pick that model; the result lands in place. Workflows with several save nodes work the same way: placeholders for runs × images per run are laid out before it runs (Results per run shows that total, each choice saying how many runs), and Results from under Settings narrows it to one node. Calling ComfyUI through Generate without choosing runs it once, as the workflow is saved. A workflow that only returns text (tagging, prompt extraction) isn't a model and stays an item ability on boards. "Import outputs" fetches by task id, so it is not on boards. Workflows and the agent keep the tools (what they do beyond generation — every output node, displayed text, previews — stays there), and the tool's description ends with "If you only need the image, use the AI generate node with this model".

A workflow tool may run for up to 30 minutes and reports progress step by step (inside a workflow the run panel shows “Sampler 12/20”); cancelling stops that one task in ComfyUI, and every output goes into the asset library — each file from every save node, plus whatever text display nodes show. It uses the GPU, so the agent asks you first (a confirmation card); once approved it runs in the background, not bound by the agent's 3-minute wait for a single tool call. Longer runs belong in generation.

Model library: browse and download models#

Open model library on the connection's title row shows every model file on that server:

• A column of folders on the left (checkpoints, loras, vae…), sorted by file count, empty ones left out; pinned at the bottom of the column are Models missing for workflows and Downloads (when there are any). In a narrow window the column becomes a drop-down at the start of the toolbar.
• A toolbar on top: search (with the number of files in scope), a Base model filter (tick several; it lists only the ones in the current folder, with counts), sorting (by name / size / date modified), three views (large cards / small cards / list), How previews show (the eye icon, see below), Fill in missing previews, and Download model. Active filters sit in a row, each removable, with Clear all. The view and How previews show are remembered on this computer. In a narrower window the toolbar stays on one line by folding buttons down to icons in order of priority (Base model first, Download model last), with their names in the hover hints.
• Cards show the preview image where there is one (an image with the same name as the model file, or the cover inside a safetensors file), always 3:4; files without one get a placeholder per folder. Small cards fit a dozen or more on a screen; large cards add the folder and how many workflows use it; the list has one file per row with folder, base model, size and date. Files judged NSFW carry an "NSFW" mark, and previews that come from Civitai say "From Civitai"; how previews show (clear, blurred, hidden) follows How previews show. Cards and list rows use a downscaled preview (512 px on the long side); the detail page shows the original. With hundreds of files only the rows in view are drawn, and the first open only fetches the previews you can see from ComfyUI.

Open a model: a fixed header shows its name and folder · size · base model, with Copy file name, Used by N workflow(s) and Generate with it on the right; below, the preview on the left and the overview, workflows and metadata on the right, each column scrolling on its own.

• Base model: SDXL, Illustrious, Pony, Flux, Wan, Qwen-Image, Anima, Krea 2… with a lighter line saying how it was recognized: written in the file's metadata, recognized from the structure of its weights (this covers merged checkpoints and LoRAs without metadata; it needs ComfyUI-Custom-Scripts on that ComfyUI), or guessed from its name (which may be wrong). Upscalers, detectors and the like aren't made for one base model, so they say "Not applicable" rather than unknown. Text encoders aren't tied to one base model either (one T5-XXL serves Flux, SD 3 and HiDream); instead they say which encoder they are and which base models they're often paired with: "Text encoder · T5-XXL" and a row of "Often paired with Flux, SD 3, HiDream…" in the details, "T5-XXL" and an "Often paired with …" line on the card. The type is recognized from the weights (as ComfyUI does it; this also needs ComfyUI-Custom-Scripts on that ComfyUI) and only guessed from the file name when the header can't be read, marked as possibly wrong; the pairings follow ComfyUI's own loading rules. Filtering by a base model also lists the text encoders often paired with it, marked "often paired with" — they don't count as that base model's. A file registered under several folders (ComfyUI-GGUF's unet_gguf points at the same folders as diffusion_models) is listed once.
• Trigger words: the ones the author wrote into the file, copied with a click; without those, the most frequent training tags, marked as not necessarily the author's trigger words.
• Used by workflows: saved workflows that use it, each with a button to show it in the workflow library.
• Metadata: every key and value in the file, searchable; long values fold into one line and can be expanded and copied.
• Generate with it: jumps to Create in AI Studio with a workflow that can use this file selected and that field filled. When several workflows can, you choose (the ones already using it come first); when none can, the button is disabled and its hint says why. Only trigger words the author wrote are added to the prompt.

Previews, NSFW and source#

How previews show (the eye icon on the toolbar; the model library, the workbench's Models panel and the model pickers when generating all follow it, and it's remembered on this computer):

• Previews: Clear / Light blur / Heavy blur / Hidden (just the type icon);
• NSFW previews: As usual / Blur / Hide. The two apply separately and the stricter one wins — for example "previews clear, NSFW hidden". Blurred ones clear up while the pointer or keyboard focus rests on them; hidden ones aren't fetched at all, and the details page can Show this one. The old Blur previews switch is converted on upgrade (on becomes Heavy blur).

What counts as NSFW: cards and list rows carry an "NSFW" mark whose hint says why. Four kinds of evidence; any one saying yes counts:

• Manual mark: Mark as NSFW / Mark as not NSFW in the context menu or the details, which beats everything below; Back to automatic undoes it. Kept on the Mosael side only;
• Civitai: the file was matched to a Civitai version (see below) and Civitai marks it adult, or the example shown is rated R or above;
• Metadata: adult tags make up a tenth of the training tags, or the file name or title has such words — offline, and it misses some;
• Local detection: looks at the preview itself on this computer. In How previews show, Download (22 MB) installs a small model (deployment admins only; pictures and results never leave this computer). From then on cards are checked as they appear, and the library refreshes itself when a batch is done; the hint reads "Local detection: 87% likely NSFW". It's a hint, not a guarantee.

Find on Civitai: Find on Civitai in the context menu or the details. With ComfyUI-Custom-Scripts on that ComfyUI, it has the file's SHA256 computed (big files take a while; the result is kept next to the model) and asks Civitai by hash, so a match is exactly this version; without it, it searches by "original file name + size as recorded on Civitai", accepts exactly one match, and says it matched by name. Finding runs as a background job you can watch and cancel in the job center. After a match:

• the details show the source (the Civitai version page) and how it's known; models downloaded through Mosael recorded their page at download time (HuggingFace and ModelScope file pages too). Without one it says so — no link is guessed from a file name;
• a base model only known as SDXL / Wan / Flux is refined to the one Civitai lists (Illustrious, Wan 2.2…), noted as "listed on Civitai";
• a model with no preview on the server shows Civitai's example, marked "From Civitai" in the corner — only inside Mosael, nothing changes on that ComfyUI. Which example follows the NSFW setting: the author's first one with As usual, otherwise the lowest-rated one;
• Save as preview writes it next to the model on that ComfyUI (512 wide, after a confirmation naming the server and folder, with an extra warning for name matches). Fill in missing previews on the toolbar goes through them one by one, saves hash matches right away, and lists name matches for you instead of saving them. Both write through ComfyUI-Custom-Scripts' routes; without it the buttons are greyed out and say what's missing. A preview already on the server is never overwritten.

Preview videos: when a .mp4 / .webm with the model's name sits next to it, or Civitai's examples for it are only videos (common for video models like Wan), the card shows the first frame and plays a muted loop on hover; the details can play it. Blurred or hidden previews don't play. Saving back stores the video itself (model-name.mp4) — ComfyUI's own model list only shows images, so it won't show these there. For model names with [ ], which ComfyUI can't find previews for, Mosael reads the files next to them by name.

Context menu: right-click a card or a list row, use the "⋯" in its corner on hover, or focus it and press Shift+F10 / the menu key — it's the same menu: Open details, Generate with it, Copy file name / full path, Used by workflows, Open source link, Find on Civitai, Save as preview, View large (the filtered list's clear previews in one gallery; a blurred one opens alone), Mark as NSFW / not NSFW. Items that can't be used say why. Mosael never deletes, renames or moves model files.

Downloading models#

Missing models download in one click. Models a workflow declares a download link for (as ComfyUI's official templates do) but that aren't on the server are listed under Models missing for workflows at the bottom of the column; click Download. For one the workflow gives no link for, the download dialog says which file in which folder it needs, so you can find a link and paste it.

Or click Download model and paste a link: a HuggingFace file, a Civitai model page or download link (civitai.red and civitai.green work too), a ModelScope model page or file, or any other direct link. Look up finds the file name, size and a suggested folder, and it downloads onto that ComfyUI once you confirm. The library switches to Downloads to follow the progress, and you can cancel there or in the task center; once it's done you can pick it right away when generating. A ModelScope model page with a single model file picks that file; with several, the candidates are listed and you paste the address of the one you want from its Files tab.

"Find a download" has three confidence tiers, and only the top one may be downloaded directly. When it searches Civitai, HuggingFace and ModelScope by file name, whether a candidate has been identified is a separate question from whether its name matches — and a matching file name is not proof it is the file:

Tier	How it was identified	What the UI offers
confirmed	The hash matches (a hash the workflow itself declares, or the SHA256 this machine computed, resolved back through Civitai's by-hash lookup)	Download directly
exact	The file name matches exactly (case-insensitive, last segment only)	A direct link, but you confirm it
likely	Same name once the precision / quantisation suffix is stripped, or the wanted name is contained in it	A page link only, never a direct link

When no hash can be computed it says why, and says plainly "so these are name matches, not the confirmed file" — one sentence per cause (that machine has no ComfyUI-Custom-Scripts / the file is not on that machine yet / that ComfyUI isn't connected). Softening that into "confirmed" is not allowed. Nor does it choose for you: a likely candidate opens a page you can look at first.

Good to know:

• Existing files are never overwritten: if the folder already has that name you're asked to pick another (with a suggestion). Mosael never deletes or renames model files.
• When ComfyUI runs on another machine, that machine's ComfyUI-Manager does the download: there is no byte progress, and cancelling in Mosael only stops waiting while the download carries on over there — the download dialog says so first. A LAN ComfyUI started with --listen 0.0.0.0 won't let the Manager install models over the network by default: on that machine open ComfyUI/user/__manager/config.ini, set network_mode to personal_cloud and restart ComfyUI (the library spells out the reason and this step).
• When ComfyUI runs on this computer, Mosael writes straight into its models folder, with progress, cancel and a free-space check first.
• For gated HuggingFace repositories, Civitai models that need a login, or private ModelScope models, enter a "HuggingFace token", "Civitai token" or "ModelScope token" in the connection's credentials. Each token is sent only to its own site; when a download through ComfyUI-Manager needs the Civitai token, the download dialog warns that it stays in that machine's task history, and that HuggingFace and ModelScope tokens can't be passed through the Manager at all.

When it can't be read, the middle of the library says "Couldn't read the model library" with one sentence on what to do, and the raw error under Details; next to it are Retry and Check connection settings (closes the library, expands the connection and lands on the server URL field).

The model library shows up when generating#

In AI Studio, boards and the workflow generate node, the field that picks a checkpoint or LoRA (or a VAE, text encoder and the like) is a list with thumbnails: each item shows its base model and first trigger words, which can also be searched; files without a preview get a placeholder per folder, and thumbnails follow How previews show. After picking a LoRA with trigger words, the line below lists them and Add to prompt appends them (skipping any already there).

Workflow library: browse and manage the server's workflows#

Open workflow library on the connection's title row looks just like the model library:

• The left column: All, then the folder tree of workflows/ on that machine — the same folders as ComfyUI's own Workflows sidebar, sorted by name, subfolders indented, each count including its subfolders; empty folders are listed too. Missing nodes or models is pinned at the bottom, and once you have deleted workflows in Mosael, a Trash as well. Pick a folder to see just it and what's below it; the search box then says "Search N workflows in “that folder”".
• The toolbar: search (names, paths, missing node types, models used and input / output names all count), a kind filter (image / video / audio / can't be converted), sorting (name / date modified / node count), the three views, and New and Import. They all work within the selected folder.
• Each card is a thumbnail of the workflow's node graph, drawn from the node positions, links and groups in the workflow, nodes coloured by role (loading inputs, loading models, sampling, prompts, outputs…), bypassed ones faded; below it the name, kind, node count and how many node types and models are missing.

Open one: a larger node graph on the left (with node titles and group names), and on the right:

• What it takes, what you can tune, what it produces — the same as when it serves as a model or a tool; one that can't be converted says why.
• Models it uses: whether each is on the server; the ones that are have a button to show them in the model library.
• Missing nodes: which node pack each comes from and whether that pack is installed (installed but not loaded is said separately). The source is read from the workflow's own declarations first (cnr_id / aux_id / ver), so it works offline, with no ComfyUI-Manager — and it links straight to the pack's node page or repository. The version the graph asks for and the version installed on this machine are both listed (the latter only costs an extra lookup when the graph really declares one); a ver that is a 40-character git commit is shown verbatim, never parsed or compared. A source of comfy-core is a separate case: that is something ComfyUI ships, so it says "this ComfyUI may be too old" instead of telling you to install a pack.
• Missing models: a Download on each row opens the model library's download dialog with the link, folder and file name written in the workflow. The model's hash travels with it, which is what makes the "download directly" tier possible (see Find a download's three tiers above).
• Latest output and Used in Mosael by: the workflow nodes and board items in this workspace that pick it, linked.

The header has Generate with it (jumps to AI Studio with this workflow selected; disabled with the reason when it isn't a generation model), Open in workbench (Open in ComfyUI in the web app) and More actions.

The context menu: right-click a card (or a row in the list), click the ⋯ that appears in its corner on hover, or select it and press Shift+F10 / the menu key — it's the same menu: Open details, Open in workbench (Open in ComfyUI in the web app) | Edit forms… | Copy…, Rename…, Move to…, Export JSON | Copy path | Download missing models, Install missing nodes (only when something is missing; they open the details at that section) | Delete…. Items that can't be used right now are greyed out with the reason underneath (the connection didn't report ComfyUI's address, a workflow that can't be converted has no forms to edit yet…). More actions in the details header has Copy, Rename, Move, Export, Copy path and Delete as well.

Changing files on that machine is always confirmed first, naming the server whose workflows/ folder is being changed:

• Copy… / Rename…: the path may include subfolders, and .json is optional; a name that won't work (.., backslashes, :*?"<>|, a leading dot) is pointed out on the spot. If that server already has the name, nothing is overwritten and a suggestion is offered. A copy gets a free name by default; done from the details you land on the new one, done from the list (context menu) you stay on the list. Renaming here carries Mosael's references along: board cells, AI Studio sessions (and their generation records), workflow nodes, scheduled tasks and default models move to the new name, and the confirmation lists them first. Only this connection's references move — another connection pointing at the same ComfyUI is left alone. Renaming or moving a file in ComfyUI's own interface isn't followed: Mosael doesn't know the new name, so those places say the workflow is gone and you choose it again there.
• Move to…: pick a folder (or the top of workflows/); the name stays. You can also drag a card onto a folder (or All) on the left: dropping it opens the same confirmation with that folder already chosen. A workflow with the same name already there is never overwritten — you get a suggestion; if something in Mosael uses the workflow, the confirmation lists it — those places follow it to the new path.
• Delete…: not a real delete — the file moves into a trash folder on that machine (.mosael-trash/workflows), and the confirmation lists what in Mosael uses it (those will say the model can't be found when they run). Deleted ones are under Trash in the left column and can be restored, under a new name if the old place is taken. Mosael has no "empty trash" — to really delete them, remove that folder on the machine.
• Export JSON: downloads to this computer without touching the server. Copy path: puts its path relative to workflows/ on the clipboard.

Folders: New folder at the top of the left column creates one inside the selected folder (or at the top when none is selected); right-clicking a folder (or its ⋯ on hover, or Shift+F10) also offers New subfolder…, Rename… and Delete…. All of them are confirmed and go through ComfyUI's own API:

• New: ComfyUI has no "make a folder" call, so Mosael writes a hidden placeholder file, .mosael-folder, into it (ComfyUI creates the folder when it writes a file). ComfyUI's own sidebar only lists folders that hold a workflow, so an empty one shows up there once something is moved in. An existing name (ignoring case) isn't created again; you get a suggestion.
• Rename: changing the parent in the path moves it into another folder. The whole folder moves at once and the workflows in it get new paths — the confirmation says how many, and which of them something in Mosael uses (those follow to the new paths). An existing target is never merged into (you get a suggestion), and a folder can't be moved into itself.
• Delete only empties: while a folder still holds files (workflows, or something else copied in, like an archive) the menu item is greyed out and says how many — move them out or delete them one by one first (each confirmed, each restorable from Trash). An empty folder moves into the trash folder (ComfyUI's API can't delete folders, and Mosael never hard-deletes); nothing new appears under Trash. Right before deleting, Mosael asks the machine again: if something was saved into the folder from ComfyUI in the meantime, it isn't deleted and you're told how many files it now holds.

After any change the workflow library, the generation models and the tool list refresh. Before each change the plugin checks the machine again: a workflow that's no longer there, a taken target, a folder that's no longer empty — each is reported as it is, nothing is forced, and the list is read again.

One button opens a workflow: in the desktop app it's Open in workbench, which opens this ComfyUI's canvas in the connection's own built-in browser and opens this workflow (the same as clicking it under Workflows on ComfyUI's left side; unsaved changes already open there are kept), with Mosael's panels beside it (see Workbench below; collapse them and it's a plain ComfyUI canvas). The web app has no workbench, so it's Open in ComfyUI: ComfyUI opens in a new tab and you're told which workflow to click under Workflows. Save in ComfyUI, come back to Mosael, and the workflow library refreshes itself, still on the same workflow. If ComfyUI sits behind a reverse proxy with login, sign in once in that built-in browser.

New: New in the toolbar starts a new workflow on this ComfyUI's own canvas. The desktop app opens the workbench and runs the same command as “Workflow → New” in ComfyUI's menu on its canvas (it opens in a new tab; the workflows already open stay as they are); the web version opens ComfyUI in a new tab, where you click “New”. Build it, save it with Ctrl+S in ComfyUI, come back to Mosael, and the workflow library refreshes itself with the new workflow in it. If this ComfyUI frontend has no such command, Mosael says so and leaves the canvas open, so you can click “New” in ComfyUI yourself.

Canvas navigation: the workbench's top bar has a Trackpad / Mouse switch. Trackpad pans with two-finger scrolling and zooms with a pinch (left-drag selects); Mouse zooms with the wheel and pans by dragging empty space (ComfyUI's own default). It defaults to Trackpad on a Mac and Mouse elsewhere, and each connection remembers its own choice on this computer. It applies only to this connection in Mosael: ComfyUI keeps this setting on the server, so Mosael sets it and then blocks the write back to the server. Switching to Trackpad on your Mac while using someone's ComfyUI on a Windows machine leaves their own setting untouched. It is set again every time the ComfyUI page reloads. If the ComfyUI frontend is too old to have this setting, the switch is hidden and a small icon says why.

Forms: pick the items others fill in#

A workflow can have dozens of parameters while whoever fills it in only needs three or five. In a workflow's detail, click New form in the Forms section (or click an existing form) and build it the way you would build any form. A workflow can have several forms (say "Quick" exposes just the prompt and "Fine-tune" also exposes size and steps), each one an entry of that workflow.

At the top of the editor are Results from (see below) and the row of forms: click one to switch to it; New form starts blank, from a suggested set, or as a copy of the form you're editing; the "⋯" copies or deletes the current one. Before deleting, it lists where this workspace still uses the form (boards, workflows, AI Studio sessions) — afterwards those places say "This form no longer exists" and are not switched to the full workflow for you. Below that are the form's title (required: several forms all called "Form" can't be told apart) and a description (one line for whoever fills it in), with a small line saying where it is kept. Under that:

• From the workflow (left): everything the workflow can take, grouped by node. A group is named after its node: the title you gave it in ComfyUI, or else ComfyUI's own name for that kind of node ("KSampler", "Lora Loader 🐍"), never an internal class name such as LoraLoader|pysssss; seed, size and runs sit in the "Whole workflow" group. Each row shows the name and the value saved in the workflow; click + to add it to the form, and click the tick on an added row to take it off again. You can search names or nodes, and hovering shows ComfyUI's description of the input plus the node number and class (for troubleshooting). Nodes inside a subgraph can't be added yet.
• Selected items (middle): each picked item is a card with an icon for its kind (text, image, model, number, choice…). Drag the handle to reorder, or focus the handle and press ↑ ↓; rename an item in place ("Portrait photo", "Style"). A card's Settings let a text item be the main prompt (it goes into the prompt box of AI Studio and boards; off, it is a text field of its own on the form), narrow a dropdown or model picker to the choices you tick, move it up or down, or remove it. While the form is empty, Start with a suggested set picks the prompt, negative prompt, main model, seed, size, runs and every image / video / audio input; adjust it from there. Leaving the form empty is fine too: people then see everything that can be filled in.
• Results from (above the row of forms; it belongs to the workflow, not to one form): when the workflow has several nodes that produce images, click Only this node's images on the one you want. From then on, when the workflow is used in AI Studio, boards or workflow nodes (the full workflow and every form), only images from the marked nodes are kept and the other preview nodes are left out; with none marked, Mosael guesses the final result. A marked node says "Results come from this node" and can be undone. "Results from" can still be changed every time.
• Preview (right): exactly what people will see, drawn with the generation panel's own controls; you can try filling it in and nothing is saved. While the form is empty it shows what people see today (everything that can be filled in).

The footer says when there are unsaved changes, and closing with changes asks first. Save to workflow… asks first, naming the server and the file: the forms are saved inside this workflow file (all of them at once), so they travel with copies, exports and other ComfyUI servers, and everyone using the same ComfyUI sees the same ones. Only the forms change; nothing else in the workflow is touched. If the workflow is open in ComfyUI with unsaved changes, saving it there will undo this change; if it was just saved in ComfyUI, Mosael doesn't write and asks you to open it again. With no form left, the forms are removed.

The workbench's Forms tab uses the same editor; the column is narrow, so the three parts become the Available / Selected / Preview tabs. The dialog does the same in a narrow window.

Once a workflow has forms:

• Each form is one more entry of the workflow; the full workflow stays. In AI Studio, boards, workflow nodes and the default-model picker, a workflow's entries sit together, one row each: the row with the workflow's name is the Full workflow (every fillable item — no need to edit a form to tweak steps or the seed once), then each form, in your order; the second line says which entry it is and which server. Searching by a form title, the workflow name or the file name finds them; a hit keeps the workflow's other entries next to it and the matching row is bold. Once picked, the button under the prompt box shows the name, and hovering says which workflow it comes from. In the workflow library the workflow gets one more line, “Forms: Quick, Fine-tune”, and searching a form title finds the workflow too. The agent in the workbench gets the forms; on the Plugins page the full workflow's tool is marked “Not for the agent”.
• Forms saved earlier need one upgrade. Forms made before use an older format that the current plugin doesn't read: those workflows show no forms until upgraded, and cells or sessions pointing at them say "the forms are in the old format; upgrade them in the workflow library" when run. You get a notification after connecting, and a banner at the top of the workflow library: Review and upgrade lists the files to rewrite on that server — only Mosael's marks in each file change, not a byte else, and any file just changed in ComfyUI is skipped. One confirmation upgrades the whole server and tells you how many were upgraded and which were skipped. Afterwards the places that used a form still use it.
• The form shows only the items you picked, in your order, with your names; the tool "Workflow · name" takes only those items too.
• Items you didn't pick run as authored: a prompt field that isn't the main prompt keeps the text saved in the workflow, an unpicked seed follows the workflow's own setting (a fixed seed stays), and values saved on a board cell earlier are no longer written into the graph.
• Several loader nodes each have a name: the corner of AI Studio thumbnail, the hint on a board's input slot and the line under a workflow node's field say "Portrait", "Background", so it is clear which image goes to which node.
• When the workflow changed in ComfyUI and an item no longer matches (the node was muted or deleted, the input became a link, a narrowed choice is gone), it is left off the form. The editor marks the item with the reason: when only narrowed choices are gone, Keep only the choices still there makes it usable again; otherwise remove it, or clear them all with "Remove the N invalid item(s)". The workflow's detail lists them too, and Remove invalid items… clears them in one go.

Importing workflows from elsewhere and completing them#

Import in the toolbar (or dropping files onto the workflow library) takes:

• the JSON from ComfyUI's Save / Export and from Export (API), pasted or as a file;
• PNG / WebP images ComfyUI saved (with the workflow embedded);
• archives (the first workflow is taken, the rest noted);
• links: the address of the file on HuggingFace, Civitai or ModelScope, or this ComfyUI's own address; for any other site, download the file first and drop it in.

Read it shows a preview first: where it was found, UI format or API format (API format has no layout, so node positions are arranged automatically), the node graph, what it takes, missing nodes and packs, missing models, and the path it will be saved as (the suggested name by default, another one if that's taken). Only Save on that server writes it into that server's workflows/, never overwriting anything. You land on it afterwards and complete what's missing from its details.

Installing missing node packs: when that ComfyUI has ComfyUI-Manager, a pack that isn't installed has Install next to it under Missing nodes. The confirmation says this changes that machine (the Manager installs it into ComfyUI/custom_nodes with its Python dependencies), that ComfyUI must restart to load it, and that a restart interrupts running tasks. Installing is a background task with progress shown below; when it's done, Restart ComfyUI (also confirmed first), and the workflow library lists everything again once ComfyUI is back. If the Manager's security settings refuse to install or restart, you're told what to change or how to install by hand; without a Manager Mosael can use (the pip version, V4; the old one isn't supported) you're told how to add it, or to install the pack on that machine yourself. Missing models are downloaded through the model library (see above).

Workbench: Mosael's panels beside ComfyUI's own canvas#

In the desktop app, Open in workbench at the top of a workflow's detail in the workflow library, New in the library toolbar, and Open in workbench under a selected ComfyUI workflow in AI Studio's engine settings all open the workbench full screen: the left side is this ComfyUI's own canvas (its own interface, with every custom node working as usual), and everything from Mosael is drawn beside it:

• Top bar: the connection, the workflow name, a dot when there are unsaved changes, canvas navigation (trackpad / mouse), Save (the same as ComfyUI's own Save: it saves into the workflow file on that ComfyUI; an unsaved workflow asks for a name; ⌘S / Ctrl+S does the same while focus is in the top bar or the column), Run, and a button to hide or show the column on the right. Drag the column's left edge to make it wider or narrower (or use the left/right arrow keys on that edge; double-click resets it); the width is remembered on this computer and the canvas makes room.
• Models: select a model-loading node on the canvas (checkpoint, LoRA, VAE, ControlNet, upscaler…) and only the models in its folder are listed, with previews, base model families and trigger words, searchable and filterable by family; click a row to fill it into that input (it checks the input's dropdown first), click a thumbnail to view it larger (the page's clear previews in one gallery; a blurred or hidden one opens alone). Thumbnails follow How previews show, with the NSFW and From Civitai marks, and the panel has its own How previews show button. If the file the input points at isn't on this ComfyUI, Find a download or paste a link right there, check it and confirm to download it into that folder; once it's downloaded the canvas dropdowns refresh and the new file is in them. When the selected node is a CLIP loader, the text encoders that fit its current type come first (type wan means UMT5-XXL) and the ones outside that type's recipe come last, marked "Not in the wan recipe"; a few that ComfyUI loads the same whatever the type says (such as Anima's Qwen3 0.6B) aren't marked.
• Missing: the nodes and models the graph on the canvas right now (unsaved changes included) is missing, in one list that follows the canvas: switch workflows or edit the graph in ComfyUI and it checks again by itself (Check again is still there). Every item can be located: the node using it is selected and centered on the canvas (several places cycle on each click; a node inside a subgraph opens that subgraph first, or the panel names the subgraph when the frontend can't open it). Missing nodes from the same pack are grouped under one Install (through ComfyUI-Manager, confirmed in place; ComfyUI has to restart to load it, so save the canvas before restarting); without ComfyUI-Manager the panel says it can't tell or install packs. Download a model the workflow gives a download address for; otherwise Find a download searches Civitai, HuggingFace and ModelScope by the file name (the full name first, then without the extension) and lists the site, repository, exact file name, size and base model; only the hash-confirmed tier offers "download directly" (see the three tiers above) and it never picks a similar one for you; click one to confirm in place and download it into that folder, or paste a link right there when nothing turns up. After a download or install finishes it checks again by itself.
• Forms: the editor from the workflow library, bound to the graph on the canvas (several forms, new, copy and delete work the same). Sync to canvas only puts the forms onto the nodes on the canvas — nothing is saved yet; Save in the top bar then stores them in the workflow file, together with any other change on the canvas.
• Run & results: Run runs the graph on the canvas right now (including unsaved changes) as an ordinary generation task (it shows in the task center, can be cancelled, is resumed after Mosael restarts, and its results go into the asset library). The canvas highlights the running node as usual and the panel says which node is running and at which step; finished results are grouped by the node they came from, labeled with the node's name; click one to view it larger (the run's outputs in one gallery). Each group has Only this node's images, which marks that output node (not this one picture): from now on, when this workflow runs from AI Studio, boards or workflow nodes, only that node's images are kept and other preview nodes are ignored (on the canvas; it takes effect once saved). The marked group says Results come from this node and can be undone; marks on other nodes are named too. Switch workflows in ComfyUI and this workflow's runs come first, with the earlier ones under Runs of other workflows. A new workflow has to be saved once before it can run here.
• Assistant: the same agent panel as on workflows, boards and the editor, docked in this column. Each workflow on the canvas has its own conversations, and switching tabs switches to that workflow's (they are all in AI Studio's history, marked with the ComfyUI workflow they were opened in). Saving, renaming or moving a workflow (in ComfyUI or in Mosael's workflow library) takes its conversations along, and a tab the agent opens for you carries on the conversation that opened it; what you say here gets the agent the tools for ComfyUI workflows. It knows which ComfyUI is open, its version, which workflow is on the canvas, whether it has unsaved changes, what is selected and whether the last run failed; the graph itself isn't stuffed into its context, it reads it when it needs to. Ask what's wrong with this workflow and it reads the canvas, runs a diagnosis and says per node what's wrong, why and how to fix it: missing nodes and models, mistyped links, unconnected required inputs, values outside a dropdown or range, widths and heights that aren't a multiple of 8, base models that don't match a LoRA, and the last run's error split onto the nodes (subgraphs included). Say I want a workflow that does X with Y and it starts from the official ComfyUI templates, adapts what it can to the models on this machine (the same file in another subfolder, another precision of the same model) and says how big each missing model is and how much that adds up to. Ask whether a custom node pack is safe to install and it checks the official Comfy registry: whether the newest version is Flagged or Banned, the latest normal version, the publisher, how many people use it, whether its dependencies touch PyTorch, and whether it fits this machine's OS, GPU and ComfyUI version. Click a #12 (#12:5 inside a subgraph) in a reply to locate that node on the canvas; every diagnosis item has Locate and Fix this — Fix this asks it to propose a change for that item alone. Ask it to change the workflow ("wire #8's vae correctly", "add a LoRA", "set steps to 30") and it first lays out a change list: which nodes are added, which links are made (and which they replace), which fields go from what to what, with a check before and after; nothing touches the canvas until you click Apply, and the whole batch is a single undo step, so one Ctrl+Z takes it back. Changes inside a subgraph change that subgraph's definition — the list says how many places it is used in the workflow and that every one of them changes. A batch that would add errors is fixed by the agent before it reaches you. Ask it to create one and it opens the official template in a new tab (your open workflows stay as they are), says how many models are missing and how big they are in total, and the card's Download takes you to Missing. It never saves for you: changed and new workflows stay unsaved until you save them in ComfyUI, wherever you like. Downloading models, installing node packs and test runs come in a later version.

The workbench talks to the canvas through a fixed script that Mosael's main process injects; only Mosael reads the canvas, and the page can't call into Mosael. If the ComfyUI frontend is too old and lacks something, that part says “This ComfyUI frontend doesn't support …” and the canvas keeps working as a normal ComfyUI. Click Back to Mosael and the workflow library refreshes itself. The web version has no workbench (the workflow library offers Open in ComfyUI, which opens ComfyUI in a new tab).

Progress, cancel and restarts#

• Progress comes from ComfyUI itself: the task center shows which node is running (by the name you gave it), the step, and how many nodes are done.
• Cancel in the task center really stops this one task in ComfyUI (interrupted if running, removed from the queue if waiting) without touching anyone else's task on the same server.
• If Mosael restarts mid-generation (after an update, say), it resumes waiting for that task instead of submitting it again.
• A single generation may run for up to 6 hours; split longer videos into parts.

Upgrading from an earlier version#

Earlier versions had ComfyUI as a provider under Settings → AI image; upgrading moves it over automatically:

• each old connection becomes a ComfyUI plugin connection (URL, enabled state and any pasted template are kept, and network:comfyui is already granted);
• boards, workflows, scheduled tasks and generation history that picked a “workflow” now use that workflow model directly, with the workflow parameters you had set;
• the old “workflow” model becomes “API template” on connections that had a template and “Built-in text-to-image” for image generation otherwise. A video “workflow” without a template never worked; it is left as it was and reports that the model is unavailable — pick a video workflow instead.

ComfyUI connections you already have get the new tools automatically after upgrading, switched on as listed above.

Upgrading to this version switches the connection off once: the plugin now declares exactly what it does, which is four more permissions — network:huggingface, network:civitai, network:modelscope (the model library looks up links and downloads models from these sites) and filesystem:write (writing into ComfyUI's models folder when it runs on this computer). The top of the connection card lists them and Grant these 4 resumes it right away; earlier grants are kept. The plugin list marks it Needs permission. This plugin version declares three more (network:github, network:pypi, network:pytorch, which installing ComfyUI on this computer needs), so an upgraded connection is switched off once more until you grant them; a later version adds network:comfy-registry (the workbench Assistant checks the official Comfy registry), granted the same way. After a plugin update Mosael rereads every connection's models and tools within a minute, so defaults on the forms (such as one image per run) follow without a manual refresh.

Workflows it can't read: export the API format and import it#

Mosael reads workflows in the UI format ComfyUI saves, following the same rules ComfyUI uses when it queues them: bypassed nodes pass their inputs straight through, muted nodes don't run, helper nodes such as Reroute, Primitive and Get / Set are resolved, subgraphs are expanded into their nodes, and workflows saved by older ComfyUI versions are read too. Convert legacy group nodes to subgraphs in ComfyUI and save again. A few unusual ones (custom nodes whose inputs are added on the fly by a UI extension) may not convert (“List workflows” lists them with the reason). For those, use Export (API) in ComfyUI and import that JSON into the workflow library (Open workflow library on the connection card → Import): it is converted to UI format and saved as an ordinary workflow, so it shows up in the model pickers and as a tool. The connection's former “API template” field is gone; upgrading drops it from stored connections.