Comfy Cloud in chat, Cowork, and Claude Code: the hosted MCP connector plus Agent Skills for generating images, video, audio, and 3D and searching the catalog.

GitHub stars
262

Install

/plugin install comfy-cloud@comfy-skills

Run it inside Claude Code after adding the marketplace with /plugin marketplace add Comfy-Org/comfy-skills.

Contents

Discovered from source

Skills 12

Clone a voice

Run this on the hosted Comfy Cloud connector (https://cloud.comfy.org/mcp). The user signs in with that connector's OAuth flow. There is no API key to collect, and the clone runs in the cloud, not on a local ComfyUI install.

This workflow is not one of the server's built-in product prompts. The tool descriptions still own parameter names. Template ids and node ids in older notes go stale. Resolve them with search_templates and get_template_schema on this run.

Consent, before any generation

Voice cloning reproduces a real person's voice. Proceed only when the clip is the user's own voice, a voice they have explicit permission to clone, or a fictional or synthetic voice with no real person behind it. If the request would impersonate someone to a third party, put words in a real person's mouth that they did not say, or pass as a genuine recording of something they never said, stop and say why. If it is ambiguous, ask who the voice belongs to and what the audio is for before spending credits.

Reference clip

Ask for a clip when they have not given one. One speaker, no music bed, natural pace, roughly 10–90 seconds. A noisy clip produces a noisy clone. If the clip has music or a second speaker, ask for a cleaner one. In chat, ask them to attach the clean clip. Trim with a local tool only when this session has a shell and they want a shorter window.

What to do

  1. upload_file the clip and keep the returned name. Keep the upload and the generation in the same signed-in session.
  2. search_templates for voice cloning or reference text-to-speech in the language and speaker count they asked for. Read get_template_schema and override the audio input and the text (or dialogue) input it lists. Do not reuse node ids from a previous template.
  3. For several lines, prefer one batch submit if the server exposes it, with a different seed per line, then wait until the batch is finished before collecting outputs.
  4. Wait with wait_for_job (or the batch wait tool), then get_output. In chat, share the returned links. When a download command exists and this session has a shell, run it unchanged.
  5. Change one setting at a time, and try a new seed before retuning. Say which control you changed.

A non-fatal widget warning on a load-audio node is not a failed job. Read the tool result before resubmitting. Discovery does not spend generation credits. This generation needs an active Comfy Cloud subscription. If a run is refused, check get_billing_status and report what it says.

Consistent characters

Run this on the hosted Comfy Cloud connector (https://cloud.comfy.org/mcp), signed in with OAuth. There is no API key to collect, and there is no local ComfyUI install to start.

The live recipe is on the server, not in this skill. Call get_creative_technique the way that tool's description says to request the consistent-characters technique, and read a comfy://guides/techniques/ resource when the server lists one for this task. Follow that text. It is refreshed from the catalog. Do not type node class names, model ids, or slot paths from memory. If the tool returns nothing for this technique, say so, then use the rules below and discover nodes with search_nodes and get_node.

Rules that stay true as the catalog moves

  • One reference set per character. Generate or upload each character in its own run so traits do not bleed. upload_file anything the next job must load. A saved output is not automatically a loadable input.
  • Reuse those same reference files on every shot. A previous shot can guide lighting. It is a poor identity reference, because drift compounds.
  • One image per reference slot. Copy slot names from get_node for the node you selected. A flat array is not a substitute when the schema is a list of slots.
  • The prompt names which slot is which character, with a few traits that must survive, and it states how many people are in the frame.
  • For motion, search_templates for reference-to-video and wire the same references. Do not pick a video family by memory.

Show a couple of seeds and let them choose. Regenerate the shots that drifted, with the same references. Discovery does not spend generation credits. A generation needs an active Comfy Cloud subscription.

Generate a 3D model

Run this on the hosted Comfy Cloud connector (https://cloud.comfy.org/mcp). The user signs in with that connector's OAuth flow. Use the signed-in account. There is no API key to collect in chat, and there is no local ComfyUI install to start.

The server's tool descriptions and the built-in generate-3d prompt own the arguments. The catalog of 3D templates and nodes moves, so discover it. Do not invent a model or node name.

What to do

  1. Image-to-3D is the common case. When the user supplies a reference image, upload_file it first and use the returned name as the image input in whichever route runs below (partner_generate media inputs, a template input, or a loader node). When the user names a 3D provider, search_nodes in the partner 3D category. Try partner_generate with the 3D type that tool documents and your best-guess model slug. Its description names providers, not model ids. When it succeeds, show its result and stop; do not run a template or graph after it. A wrong slug is rejected before the job is queued, and the error names the closest real slugs (Did you mean). Re-call once, and only when a suggestion keeps the provider prefix of the slug you guessed. If the bounce names a params.model tier, send that tier with the slug. A tier-shaped guess belongs in params.model; re-calling the bare slug runs that entry's default tier at a different price. Say which slug you switched to. If that re-call bounces too, stop. If no suggestion keeps your guess's provider prefix, do not re-call — that call queues and charges — and ask which model to use. If the tool says "unknown model" with no close match, "not yet implemented", or that it does not serve 3D, continue with a template. That fall-through still runs on Comfy Cloud. If they asked to build a workflow, skip the shortcut and wire the partner node in.
  2. Search search_templates for image-to-3D or a broader 3D query, using the tool's tag filter when a text search is noisy. Clone a fit with get_template_schema and run_template before hand-building.
  3. If no template fits, search_nodes with typed filters for a 3D file or mesh output, a 3D category, and image input when they supplied a picture. Use search_models for checkpoints those nodes require.
  4. The graph needs the uploaded image (or a text prompt) and a 3D save or output node. Give every node a _meta.title.
  5. 3D jobs are often slower than images. Wait with wait_for_job, then get_output. Tell the user which files came back (mesh, texture, preview). In chat, share the returned links. When a download command exists and this session has a shell, run it unchanged.
  6. When they asked for a workflow they can reopen, save_workflow and return get_workflow_canvas_url. Say the layout is auto-generated.
  7. When they ask to adjust this result (seed, prompt wording, or a different reference image) rather than a new subject, do not rebuild the graph and do not re-send the JSON. Call submit_workflow with from_prompt_id set to the run being adjusted and input_overrides holding only the changed inputs ({nodeId: {inputName: value}}). If you do not know the node id, call get_job_status with include_workflow: true on that prompt id first. A new reference still goes through upload_file; override the loader input with the returned name. If that result came from partner_generate, there is no workflow to rerun: call partner_generate again with the changed fields. If they want this exact mesh edited (keep the mesh, change the texture) rather than the workflow's inputs changed, use use_previous_output or partner_generate media inputs.

If a step fails, search again for a current alternative. Discovery does not spend generation credits. A generation needs an active Comfy Cloud subscription. If a run is refused, check get_billing_status and report what it says.

Generate audio

Run this on the hosted Comfy Cloud connector (https://cloud.comfy.org/mcp). The user signs in with that connector's OAuth flow. Use the signed-in account. There is no API key to collect in chat, and there is no local ComfyUI install to start.

Voice cloning from a reference recording is a different skill. Use this one for new audio from a description.

The server's tool descriptions and the built-in generate-audio prompt own parameter names. Discover templates and nodes live. Audio node names change, including which save node is current, so take the save node from search_nodes rather than from an older note.

What to do

  1. If the user named a provider or model and wants finished audio, look it up with search_nodes. When the match is a partner model, call partner_generate for audio. Its description names providers, not model ids, so pass your best-guess model slug. A wrong slug is rejected before the job is queued, and the error names the closest real slugs (Did you mean). Re-call once, and only when a suggestion keeps the provider prefix of the slug you guessed. If the bounce names a params.model tier, send that tier with the slug. A tier-shaped guess belongs in params.model; re-calling the bare slug runs that entry's default tier at a different price. Say which slug you switched to. If that re-call bounces too, stop. Suggestions are ranked across the whole registry, so one may name a provider the user never asked for. If none keeps your guess's provider prefix, do not re-call — that call queues and charges — and ask which model to use. Inside submit_batch, resend only the bounced item. If the tool says "unknown model" with no close match, or "not yet implemented", or the node is not a partner node, continue below. If they asked to build a workflow, skip partner_generate and wire that node into the graph. When partner_generate succeeds, hand back the links it returns and stop. Do not continue to a template or graph, which would run and charge a second generation.
  2. Otherwise prefer a template. search_templates for speech, music, or sound effects, and set the tool's audio media-type filter when it has one. Run a fit with get_template_schema and run_template.
  3. If no template fits, search_nodes and search_models for the task, then submit a graph. Give every node a _meta.title. Include a prompt or source input and a current audio save node wired to the result. Partner nodes often omit the save node.
  4. Wait with wait_for_job, then get_output, with a short description so the file has a useful name. In chat, hand back the link the tool returns. When a download command is present and this session has a shell, run it unchanged.
  5. When they asked for a workflow they can reopen, save_workflow and return get_workflow_canvas_url. Say the layout is auto-generated.
  6. When they ask to adjust this result (seed, prompt wording, duration, or a different reference) rather than a new sound, do not rebuild the graph and do not re-send the JSON. Call submit_workflow with from_prompt_id set to the run being adjusted and input_overrides holding only the changed inputs ({nodeId: {inputName: value}}). If you do not know the node id, call get_job_status with include_workflow: true on that prompt id first. A new reference still goes through upload_file; override the loader input with the returned name. If that result came from partner_generate, there is no workflow to rerun: call partner_generate again with the changed fields. If they want this exact audio edited rather than the workflow's inputs changed, use use_previous_output or partner_generate media inputs.

Fewer audio templates may exist than image templates. Say what the search returned. Discovery does not spend generation credits. A generation needs an active Comfy Cloud subscription. If a run is refused, check get_billing_status and report what it says.

Generate an image

Run this on the hosted Comfy Cloud connector (https://cloud.comfy.org/mcp). The user signs in with that connector's OAuth flow. Use the signed-in account. There is no API key to collect in chat, and there is no local ComfyUI install to start.

The server's tool descriptions name the parameters and the current model ids. When the user opens the built-in generate-image prompt, that prompt is the long procedure. Follow the live tool descriptions for arguments. Discover template, model, and node names with the tools. Do not copy them from memory into the graph.

What to do

  1. When they supply a source image, upload_file it first and use the returned name in whichever route runs below (partner_generate media inputs, a template input, or a loader node). Do not inline image bytes.
  2. If the user named a provider or model and wants a finished image, look that name up with search_nodes. When the match is a partner model, call partner_generate for an image. Its description names providers, not model ids, so pass your best-guess model slug. A wrong slug is rejected before the job is queued, and the error names the closest real slugs (Did you mean). Re-call once, and only when a suggestion keeps the provider prefix of the slug you guessed. If the bounce names a params.model tier, send that tier with the slug. A tier-shaped guess belongs in params.model; re-calling the bare slug runs that entry's default tier at a different price. Say which slug you switched to. If that re-call bounces too, stop. Suggestions are ranked across the whole registry, so one may name a provider the user never asked for. If none keeps your guess's provider prefix, do not re-call — that call queues and charges — and ask which model to use. Inside submit_batch, resend only the bounced item. If the tool says "unknown model" with no close match, or "not yet implemented", or the node is not a partner node, continue below. If they asked to build or create a workflow, skip partner_generate and wire the partner node into the graph instead. When partner_generate succeeds, it returns the output only: show the image or signed URL it returns, leaving the query string as returned, and stop. Do not continue to a template or graph, which would run and charge a second generation.
  3. Otherwise prefer a template. Search with search_templates for the task they described. When one fits, read get_template_schema and run it with run_template. Hand-build a graph only when nothing fits, using search_models and search_nodes for the pieces.
  4. A graph needs an input that carries the request and a save or output node wired to the final image. Partner nodes often omit the save node; add one, or the job returns nothing. Give every node a _meta.title that names its role in plain words.
  5. Wait with wait_for_job, then get_output. Show the image from what that tool returns. When it includes a download command and this session has a shell, run that command unchanged. In chat, show the image or the signed URL. Leave the signed URL's query string as returned.
  6. When they asked for a workflow they can reopen, save_workflow and return the link from get_workflow_canvas_url. Say that the saved layout is auto-generated. When the run used a subgraph template, say the canvas shows one collapsed node: double-click the node body to step inside, or right-click and unpack it.
  7. When they ask to adjust this result (seed, prompt wording, steps, cfg, resolution, or a different reference) rather than a new subject, do not rebuild the graph and do not re-send the JSON. Call submit_workflow with from_prompt_id set to the run being adjusted and input_overrides holding only the changed inputs ({nodeId: {inputName: value}}). If you do not know the node id, call get_job_status with include_workflow: true on that prompt id first. A new reference still goes through upload_file; override the loader input with the returned name. If that result came from partner_generate, there is no workflow to rerun: call partner_generate again with the changed fields. If they want this exact image edited ("keep this picture, make it night") rather than the workflow's inputs changed, use use_previous_output or partner_generate media inputs.

Discovery does not spend generation credits. A generation needs an active Comfy Cloud subscription. If a run is refused, check get_billing_status and report what it says.

Generate a video

Run this on the hosted Comfy Cloud connector (https://cloud.comfy.org/mcp). The user signs in with that connector's OAuth flow. Use the signed-in account. There is no API key to collect in chat, and there is no local ComfyUI install to start.

The server's tool descriptions and the built-in generate-video prompt own the call sequence and any dated model notes. Use those for arguments. Resolve model, template, and node names with the tools at run time.

What to do

  1. When they supply a source image or video, upload_file it first and use the returned name in whichever route runs below. Do not inline media bytes.
  2. When the user names a model family, check both routes before spending money: search_nodes for a partner or API node, and search_templates for an open-source template under the same family. Tell them apart with the fields those tools return (category, name prefix, tags), not with a remembered list. If only the partner route exists, call partner_generate for video, then stop, unless they asked to build a workflow. Its description names providers, not model ids, so pass your best-guess model slug. A wrong slug is rejected before the job is queued, and the error names the closest real slugs (Did you mean). Re-call once, and only when a suggestion keeps the provider prefix of the slug you guessed. If the bounce names a params.model tier, send that tier with the slug. A tier-shaped guess belongs in params.model; re-calling the bare slug runs that entry's default tier at a different price. Say which slug you switched to. If that re-call bounces too, stop. Suggestions are ranked across the whole registry, so one may name a provider the user never asked for. If none keeps your guess's provider prefix, do not re-call — that call queues and charges — and ask which model to use. Inside submit_batch, resend only the bounced item. Guessing costs one rejected call, so do not skip the tool for lack of a list. If the tool says "unknown model" with no close match, or "not yet implemented", continue with a template. If both an open-source template and a partner route exist, say so and ask which they want, unless they already chose. When they pick the partner route, call partner_generate for video as above, then stop, unless they asked to build a workflow. When they pick the open-source route, continue with a template. The open-source route has no partner fee and still spends Comfy Cloud compute credits when it runs on Comfy Cloud. Do not tell them the open-source route is gone until a broader search also misses it.
  3. Otherwise prefer a template. Search search_templates for text-to-video, image-to-video, or the task they named. Filter with the tool's tag or media-type arguments when a text search is mostly images. Run a fit with get_template_schema and run_template.
  4. Hand-build only when no template fits. Discover loaders, samplers, and video save nodes with search_nodes. Give every node a _meta.title in plain words. The graph needs an input that carries the request and a save or output node wired to the final video. Partner nodes often omit the save node.
  5. Video runs take longer than images. Wait with wait_for_job, then get_output. In chat, show the returned link. When a download command is present and this session has a shell, run that command unchanged. Leave signed URL query strings as returned.
  6. When they asked for a workflow they can reopen, save_workflow and return get_workflow_canvas_url. Say the layout is auto-generated. For a subgraph template, say the canvas shows one collapsed node and how to open it (double-click the node body, or right-click and unpack).
  7. When they ask to adjust this result (seed, prompt wording, duration, resolution, or a different reference) rather than a new subject, do not rebuild the graph and do not re-send the JSON. Call submit_workflow with from_prompt_id set to the run being adjusted and input_overrides holding only the changed inputs ({nodeId: {inputName: value}}). If you do not know the node id, call get_job_status with include_workflow: true on that prompt id first. A new reference still goes through upload_file; override the loader input with the returned name. If that result came from partner_generate, there is no workflow to rerun: call partner_generate again with the changed fields. If they want this exact clip edited rather than the workflow's inputs changed, use use_previous_output or partner_generate media inputs.

If a family search comes back empty, broaden the query once before telling the user that route does not exist. Discovery does not spend generation credits. A generation needs an active Comfy Cloud subscription. If a run is refused, check get_billing_status and report what it says.

What Comfy Cloud can do

Comfy Cloud is the hosted connector at https://cloud.comfy.org/mcp. The user signs in with OAuth on the plugin's Connectors tab, or with /mcp in Claude Code. Chat does not use an API key. Nothing here starts a local ComfyUI install. Workflows run on Comfy Cloud GPUs.

Say this briefly, in their words:

  • Generate or edit a still image from a description or a source picture.
  • Generate, edit, or extend video, including image-to-video.
  • Generate music, sound effects, or speech. Cloning a voice from a recording is a separate step and needs permission to use that voice.
  • Generate a 3D model from text or from an image.
  • Remove a background, or upscale an image they attach.
  • Search models, nodes, and workflow templates, then run a template or build a graph.
  • Keep a character consistent across shots by loading the live technique from the server.
  • Refine a previous result without rebuilding it: rerun a workflow job with only the inputs that changed. A partner-model result has no workflow to rerun, so it is generated again with the changed settings. To edit the exact image or clip they got, use that output as the new input.
  • Cancel a job or check the queue when they change their mind.

Catalog search does not spend generation credits. Running a generation needs an active Comfy Cloud subscription. Offer get_billing_status when they ask what a run will cost or why a run was refused.

Examples they can try: a mountain lake at golden hour; a short clip of a paper boat in a gutter; an upscale of a photo they attach; a template search for image-to-video.

Point them at https://docs.comfy.org/cloud/mcp for the tool list. Do not invent tools, models, or templates that search did not return.

Remove a background

Run this on the hosted Comfy Cloud connector (https://cloud.comfy.org/mcp). The user signs in with that connector's OAuth flow. There is no API key to collect in chat, and there is no local ComfyUI install to start.

The built-in remove-background prompt and the tool descriptions own the call arguments. Discover the current template and nodes. Do not pin a remover by a remembered class name.

What to do

  1. Ask for a source image if they have not attached one. upload_file it and use the returned name.
  2. search_templates for background removal or a transparent background. When one fits, get_template_schema and run_template.
  3. If none fits, search_nodes for removal, matting, or segmentation, then build a short graph: the uploaded image in, the remover, and a save node that keeps transparency (a PNG or the alpha-capable format that node documents). Give every node a _meta.title.
  4. To replace the background, composite the cutout over the new plate in the same graph, or run a second step after the cutout. Re-upload an output before using it as an input in a later job. The save directory and the load directory are not the same store.
  5. Wait with wait_for_job, then get_output. In chat, show the image or the signed URL. When a download command exists and this session has a shell, run it unchanged. Leave the signed query string as returned.
  6. When they asked for a workflow they can reopen, save_workflow and return get_workflow_canvas_url.
  7. When they ask for a different strength or model (another removal model, or a different mask threshold) and the change only touches inputs, rerun with submit_workflow, from_prompt_id of the run being adjusted, and input_overrides of only the changed inputs. Do not rebuild the workflow in that case. If the requested model needs a different node or connections, discover it with search_nodes, edit the workflow, and submit the edited workflow instead. Either way, do not re-upload the source. If you need the workflow or a node id, call get_job_status with include_workflow: true on that prompt id first.

A job with no save node succeeds and returns nothing. Discovery does not spend generation credits. A generation needs an active Comfy Cloud subscription. If a run is refused, check get_billing_status and report what it says.

Search models

Use the hosted Comfy Cloud connector (https://cloud.comfy.org/mcp), signed in with OAuth. Catalog search does not need a generation subscription and does not take an API key.

Call search_models. The tool description is the filter list. Use a text query when they did not name a type. When they name a kind (checkpoint, LoRA, VAE, ControlNet, upscaler) or a base family, set the matching filter the tool documents. Do not answer from memory, and do not add models the tool did not return.

Show the rows it returned: name, type, base model, and source when those fields are present. If the tool returns more than you should paste, show the first page it gave you and say how many more it reported. If the result is empty, broaden the query once, then say nothing matched.

Search nodes

Use the hosted Comfy Cloud connector (https://cloud.comfy.org/mcp), signed in with OAuth. Node search does not need a generation subscription and does not take an API key.

Call search_nodes. Prefer its typed filters (category, input type, output type) when they asked a structural question, and a text query when they named a feature. Read get_node before quoting slot names or option lists. Deprecated nodes are often hidden from search. Use a class the search returned.

For each hit, show the name, display name, category, and pack when the tool includes them, plus the inputs and outputs that matter for the question. When they want a pipeline, suggest a wiring only from those returned slots. If search is empty, drop a filter and try once more, then say the catalog had no match.

Search templates

Use the hosted Comfy Cloud connector (https://cloud.comfy.org/mcp), signed in with OAuth. Template search does not need a generation subscription and does not take an API key.

Call search_templates. Use a text query for a task they described, a tag filter when they named a category, and a model filter when they named a family. The tool description lists the current arguments. Do not invent template names.

Show title, the first sentence of the description, tags, and models used, when the tool returns them, plus a link to view the template if one is present. If many rows come back, show the first page and the total. If none match, relax the filter once.

When they want it run, not just listed, read get_template_schema and use run_template. That hand-off is the generation skill for the media type.

Upscale an image

Run this on the hosted Comfy Cloud connector (https://cloud.comfy.org/mcp). The user signs in with that connector's OAuth flow. There is no API key to collect in chat, and there is no local ComfyUI install to start.

The built-in upscale-image prompt and the tool descriptions own the arguments. Which upscale models exist changes, so search for them. Do not recommend a model by a name you remember unless that search just returned it.

What to do

  1. Ask for the image if they have not attached one. upload_file it.
  2. search_templates for upscale or super-resolution. When one fits the medium (photo, illustration, anime), get_template_schema and run_template.
  3. If none fits, search_models for an upscale model that matches the picture and the scale they asked for, then search_nodes for the loader and apply nodes. Wire load, upscale, and save. Give every node a _meta.title.
  4. A second pass that repaints detail is optional. Offer it when they asked for sharpness, and keep the denoise low enough that identity survives. Confirm the denoise control on the node you actually fetched.
  5. Wait with wait_for_job, then get_output. In chat, show the image or the signed URL. When a download command exists and this session has a shell, run it unchanged.
  6. When they asked for a workflow they can reopen, save_workflow and return get_workflow_canvas_url.
  7. When they ask for a different strength or model (another upscaler, or a different scale factor) and the change only touches inputs, rerun with submit_workflow, from_prompt_id of the run being adjusted, and input_overrides of only the changed inputs. Do not rebuild the workflow in that case. If the requested upscaler needs a different node or connections, discover it with search_nodes, edit the workflow, and submit the edited workflow instead. Either way, do not re-upload the source. If you need the workflow or a node id, call get_job_status with include_workflow: true on that prompt id first.

Discovery does not spend generation credits. A generation needs an active Comfy Cloud subscription. If a run is refused, check get_billing_status and report what it says.

Commands 12

Clone a voice from a reference recording and generate speech with it: $ARGUMENTS

Step 0 — Consent check (do this first, every time)

Voice cloning reproduces a real person's voice. Before generating anything, confirm the request is one of:

  • The user cloning their own voice.
  • A voice the user has explicit permission to clone (a colleague who asked for it, a voice actor under contract, a synthetic or licensed voice).
  • A clearly fictional or synthetic voice with no real person behind it.

Do not proceed if the request is to impersonate someone to a third party, put words in a real person's mouth they would object to, or produce audio that could pass as a genuine recording of something they never said. If the ask is ambiguous, ask the user who the voice belongs to and what the audio is for before spending credits. If it drifts toward deception, stop and say why.

Step 1 — Get a reference recording

Ask the user for a reference clip if they have not supplied one. What makes a good reference:

  • One speaker only. No cross-talk, no music bed, no laughter over the top.
  • 10–90 seconds. Longer does not improve the clone; 30s of clean speech beats 90s of noisy.
  • Natural speech at a normal pace — not shouting, not whispering, not reading robotically.
  • Accepted formats: .mp3, .wav, .flac, .ogg.

Reference quality dominates output quality. A noisy clip produces a noisy clone no amount of parameter tuning will fix. If the clip has music or a second speaker, say so and ask for a cleaner one rather than generating from it.

If the clip needs trimming to a clean window, do it locally with ffmpeg before uploading:

ffmpeg -y -i <source> -ss <START> -t <SECONDS> -ar 44100 -ac 1 ref.wav

Step 2 — Upload the reference

upload_file(file_path: "<absolute path to the clip>", client_os: "<darwin|linux|windows>")

Note the returned name — that is what the LoadAudio node references. On a hosted/remote session this returns a PUT command for the user's own shell; run it exactly as emitted and read name out of the JSON it prints.

Step 3 — Generate speech

Pick the Chatterbox template for the job: audio-chatterbox_tts for one voice speaking English, audio-chatterbox_tts_multilingual for a non-English target language (it adds a language input), or audio-chatterbox_tts_dialog for multi-speaker dialogue from a single script (it takes a dialog_text script and one LoadAudio reference per speaker).

Resolve that template's node ids before writing any override:

get_template_schema(template_id: "<the template name>")

None of these templates exposes a subgraph, so slots comes back empty and the nodes list is the contract: input_overrides is keyed by the node ids it returns. Find the LoadAudio node (its audio input takes the name from upload_file) and the Chatterbox TTS node (its text — or dialog_text — input takes the line to speak, alongside seed, exaggeration, cfg_weight and temperature). The ids differ between the three templates and can move when a template is republished, so take them from the schema you just fetched, not from memory. As of this writing the single-voice template resolves to:

run_template(
  name: "audio-chatterbox_tts",
  input_overrides: {
    "6": { "audio": "<name from upload_file>" },
    "4": { "text": "<the line to speak>", "seed": <vary per line>, "exaggeration": 0.5, "cfg_weight": 0.5, "temperature": 0.8 }
  }
)

Then poll get_job_status until completed and call get_output with a short description so the saved file gets a useful name.

run_template returns conversion_warning: Node 6 (LoadAudio): 1 extra widget values not mapped on this template. That is the node's audioUI preview widget and is non-fatal — the job runs as submitted. Do not cancel or resubmit over it.

For more than one line, call submit_batch once with a run_template item per line rather than running this template N times — one spend confirmation, then wait_for_batch until every job is terminal (call it again if it returns timed_out: true), then get_batch_output collects them all. Calling get_batch_output before the batch is terminal returns only the outputs that are ready so far. Vary seed per line so repeated phrases do not come out identically stamped.

Step 4 — Tuning

Change one knob at a time, and re-roll seed before reaching for the others — an odd read is more often an unlucky sample than a wrong parameter.

KnobRaise itLower it
exaggeration (0–1)more animated, more expressiveflatter, calmer, more deadpan
cfg_weight (0–1)tighter adherence to the reference~0.3 slows pacing; often clearer for fast talkers
temperature (0–1)more variation between runs~0.4 when a line keeps coming out erratic

Notes

  • Generation consumes Comfy Cloud credits and needs a workspace with credits on it. The discovery tools (search_templates, search_models) work without a subscription; this command does not.
  • upload_file accepts audio as well as images — the reference does not need to be hosted anywhere public first, and it does not need a separate API key. Keep the upload and the generation in this one MCP session.
  • If run_template reports an unknown template name, run search_templates(q: "chatterbox") and use the exact name it returns.

Combine a user's photo with another person (real or fictional) into a single composite image: $ARGUMENTS

Follow these steps exactly:

Step 1: Upload the user's photo

If the user provides a photo of themselves, use upload_file to upload it. Note the returned filename for use in LoadImage.

Step 2: Generate a reference image of the other person

Use KlingOmniProImageNode (model: kling-v3-omni) or GeminiNanoBanana2 to generate a high-quality reference portrait of the target person. Use a detailed prompt describing their iconic appearance. Save and upload the result for use as a second reference.

Alternatively, if the user provides their own reference image of the second person, upload that instead and skip generation.

Step 3: Batch the reference images

Use ImageBatch to combine both images into a single batch:

{
  "class_type": "ImageBatch",
  "inputs": { "image1": ["user_photo_node", 0], "image2": ["other_person_node", 0] }
}

Step 4: Generate the composite with Nano Banana 2

Use GeminiNanoBanana2 with these settings for best results:

  • model: Nano Banana 2 (Gemini 3.1 Flash Image)
  • thinking_level: HIGH (critical for face accuracy)
  • resolution: 2K
  • aspect_ratio: 16:9 (or match user preference)
  • response_modalities: IMAGE
  • images: connect to the ImageBatch output

Prompt structure (important):

The prompt should:

  1. Explicitly state which reference image is which ("The first image is...", "The second image is...")
  2. Emphasize EXACT face reproduction from both references
  3. Describe clothing, pose, and setting
  4. Specify lighting consistency
  5. Call out any artifacts to avoid (e.g., "NO glare on glasses, NO reflections on lenses")

Example prompt:

Create a black and white vintage 1970s photograph combining these two people.
The first image is the primary reference - reproduce this man's face EXACTLY as shown:
his specific facial features, smile, dark hair style, and black zip-up jacket. He should
be on the left. The second image shows [PERSON NAME] - reproduce their face exactly as
shown with [iconic features]. They are posing together as close friends in [setting].
[Style instructions]. Important: [any artifact avoidance instructions].

Step 5: Generate multiple variations

Submit 3 workflows with different seeds in parallel. This gives the user options to pick from since face reproduction varies by seed.

Step 6: Show results and iterate

  • Save all outputs locally and open them for the user
  • Ask which variation they prefer
  • If adjustments are needed (lighting, glare, pose), modify the prompt and regenerate with both the same seed (to stay close) and new seeds

Model comparison (from testing):

ModelFace accuracyQualitySpeed
Nano Banana 2 (HIGH thinking)BestExcellent~45s
Nano Banana ProGoodExcellent~40s
Kling O3 (kling-v3-omni)GoodGood~60s
Flux Kontext ProModerate (single ref only)Good~20s
SDXL img2imgPoorModerate~15s

Key learnings:

  • Two reference images are essential - without a reference of the second person, models rely on training data and often miss the likeness
  • Nano Banana 2 with HIGH thinking produces the most accurate face reproduction
  • Explicit prompt instructions about which image is which person dramatically improves results
  • The SaveImage output directory != LoadImage input directory on Comfy Cloud - always re-upload generated reference images via upload_file before using them in a new workflow

Generate a 3D model using Comfy Cloud based on the user's description: $ARGUMENTS

Approach: prefer a ready-made template over hand-building, and discover the current options with the tools rather than assuming a fixed catalog. Model, node, and template availability changes over time, so let the tools tell you what exists right now.

Step 0 - Partner-API shortcut. If the user named a provider or capability (Meshy, Tripo, Rodin, Tencent, and so on), find the matching node with search_nodes filtered by category: "partner/3d" (optionally add a q for the provider name). partner_generate returns only the output, never a workflow: if the user asked to BUILD or CREATE a workflow (not just for an output), skip partner_generate and continue to Step 1, wiring the matching partner node into the workflow you build. If a matching partner/3d/... node exists, try partner_generate first with type: "3d" and that provider's model slug, plus prompt and any optional fields (seed, medias[]). On success, return the artifact URL(s) and stop. If it returns "unknown model" or "not yet implemented", or says it "does not serve type" (3D has no partner_generate persist path today), continue below — the template path in step 1 does generate 3D on Comfy Cloud.

  1. Look for a template first. Call search_templates with tag: "Image to 3D" (image-to-3D is the common case), and/or q: "3d" for the broader set. If a suitable template comes back, clone it as your base workflow: swap in the user's input (such as the reference image) and adjust settings instead of building from scratch. Cloning a template is almost always faster than hand-wiring nodes, so spend real effort here before falling through to step 2.

  2. If no template fits, discover nodes structurally - do not free-text guess. Use search_nodes with its typed filters, which match against the live catalog:

    • output_type: "FILE_3D_GLB" (also MESH, FILE_3D_OBJ) to find nodes that produce a 3D file.
    • category: "3d" or category: "partner/3d" to browse the 3D nodes.
    • input_type: "IMAGE" to find what accepts an image, for image-to-3D.

    Use search_models for any checkpoints the chosen nodes require. Do not paste in remembered model or node names - query for them, because the set changes.

  3. If the user provides a reference image (image-to-3D), upload_file it first.

  4. Build a ComfyUI API-format workflow JSON, or edit the cloned template. A 3D workflow generally chains an input, a 3D generation or reconstruction node, and a 3D save/output node. Give EVERY node a _meta.title that names its role in plain words (e.g. "Load driving video", "Remove background", "Overlay graphic 1", "Save video"). The canvas shows these titles; without them the user sees only class names.

  5. Validate inputs and outputs before submitting. Confirm the workflow has:

    • at least one input node carrying the user's intent (a text prompt node, or LoadImage for image-to-3D), and
    • at least one save/output node wired to the final mesh. If you are unsure of the exact node, find it with search_nodes output_type: "FILE_3D_GLB".

    API and partner nodes often produce an output but include no save node by default. Add and wire one, or the job runs and produces nothing retrievable, wasting compute. Do not skip this check.

  6. Call submit_workflow. 3D generation can take longer than image generation.

  7. Poll get_job_status every 5 seconds until completed, showing brief status updates while waiting. If the user asks to cancel, use cancel_job with the prompt_id.

  8. Call get_output to retrieve the result. Pass a short description (for example "red sports car 3d model") so the saved file gets a descriptive name.

  9. Tell the user where the files were saved. 3D outputs may include mesh files (.obj, .glb), textures, or rendered preview images.

  10. If the user asked to BUILD or CREATE a workflow (not just for an output), after the run completes call save_workflow with the same JSON, a descriptive name, and overwrite: false — on a name collision choose a new name rather than replacing the user's existing workflow. Then call get_workflow_canvas_url with the workflow_id from the save result; if the save result omits workflow_id, find it with list_saved_workflows — never pass the filename (saved_workflow_filename publishes a PUBLIC share snapshot). If you ran a template with run_template, call get_template, apply the same input_overrides you ran with to that body (same node ids or slot paths; inputs you did not override keep the template defaults), and save_workflow the result instead, so the canvas matches the run. If you adjusted the run with submit_workflow + from_prompt_id reruns, apply each rerun's input_overrides on top, in run order, to whichever JSON you save (the built workflow or the template body), so the saved workflow matches the latest run rather than the first one. Give the user the canvas link. Mention that the saved layout is auto-generated and may need tidying. If you ran a subgraph template instead, tell the user the canvas shows one collapsed subgraph node and how to open it (double-click the node body, not its title, to step inside it, or right-click it and choose Unpack Subgraph to flatten it onto the canvas).

  11. If the user asks to adjust the result (different seed, prompt wording, steps/cfg, resolution, a different reference image) rather than a new subject: do NOT rebuild the workflow and do NOT re-send the JSON. Call submit_workflow with from_prompt_id set to the prompt_id of the run being adjusted and input_overrides holding ONLY the changed inputs ({nodeId: {inputName: value}}). If you do not know the node id, call get_job_status with include_workflow: true on that prompt_id first. A new reference image still goes through upload_file first; override the loader node's input with the returned filename. Then continue from step 7. A 3D result always came from a template or workflow (Step 0's partner_generate does not serve 3D), so from_prompt_id + input_overrides is the only rerun path. If the user wants the 3D MODEL itself edited (e.g. "keep this exact mesh, just retexture it") rather than the workflow's inputs changed, call use_previous_output with that prompt_id (pick the output_index of the mesh file), then feed the returned filename to a Load3D node — the simplest way is a mesh-input template: search_templates({ q: "3d" }) and pick one whose nodes include Load3D (the retexture, part-split and retopology ones). partner_generate does not serve 3D (Step 0) and its medias[] accepts images only; upload_file does not accept .glb/.obj, so use_previous_output is the only in-band route for a generated mesh.

If a step fails, show the error clearly and use the search tools to find a current alternative rather than assuming none exists.

Generate audio using Comfy Cloud based on the user's description: $ARGUMENTS

Follow these steps exactly:

Step 0 — Route partner-API requests directly. If the user named a provider, model, or capability (e.g. "ElevenLabs", "Stability Audio", "Sonilo"), do one search_nodes lookup with the named term. partner_generate returns only the output, never a workflow: if the user asked to BUILD or CREATE a workflow (not just for an output), skip partner_generate and continue to Step 1, wiring the matching node into the workflow you build if its category starts with partner/ (an OSS match takes the normal steps below). If the matching node's category starts with partner/, try partner_generate first — its description names providers, not model ids, so pass type: "audio" plus your best-guess model slug (a wrong one rejects before queuing and bounces back naming the closest real slugs, Did you mean: …), prompt, and any optional fields (seed/duration/medias[]). On a bounce, first look for a run_template the bounce names (a "served by the bundled template … Do not retry this slug" reply): run that template instead of re-calling. Otherwise re-call once with the suggested slug only if it keeps the provider prefix of your guess (a kling/… suggestion for a kling/… guess) AND names the same product and shape the user asked for — a text-to-video slug is not a retry for an image-, reference- or first/last-frame-to-video request (-t2v for -i2v/-r2v/-flf2v), and a sound-effects slug is not a retry for speech; for those, find the family's own api_* template with search_templates and run_template it, or ask. If the bounce lists several slugs or several params.model tiers, pick the one that matches the user's request; if none clearly does, ask instead of re-calling (the re-call is the call that queues and charges, and tiers are priced differently). Pass a tier-shaped guess as params: {"model": "<tier>"} on the slug the bounce names rather than re-calling the bare slug (that runs the entry's default tier at a different price). Say which slug or tier you switched to. If that re-call bounces too, do not re-call again — handle it as "unknown model" with no close match named (below). The suggestions are ranked by token overlap across the whole registry, so one can belong to a provider the user never named — if none keeps your guess's provider prefix, do not re-call (the re-call is the call that queues and charges): stop and ask the user which model to use; inside submit_batch resend only the bounced item — its siblings may already be queued and charged. On success, return the artifact URL(s) and stop — do NOT continue with the workflow steps below. If partner_generate returns "unknown model" with no close match named, or "not yet implemented", or the matching node has no partner/ prefix (OSS model), continue to Step 1.

  1. Use search_templates with queries like "audio generation", "text to audio", "music generation", or "sound effects" and set media_type to "audio" to find a pre-built audio workflow template. If a good template exists, use it as the base workflow instead of building from scratch.

  2. If no suitable template was found, use search_nodes to find audio-related nodes. Search for "audio" to discover available audio generation and processing nodes. Use search_models to find audio models if needed.

  3. Build a ComfyUI API-format workflow JSON with the appropriate audio nodes. Audio workflows vary depending on the task (music generation, sound effects, text-to-speech, etc.) and available nodes. Give EVERY node a _meta.title that names its role in plain words (e.g. "Load driving video", "Remove background", "Overlay graphic 1", "Save video"). The canvas shows these titles; without them the user sees only class names.

  4. Validate the workflow has inputs and outputs before submitting. Confirm the JSON contains:

    • At least one input node carrying the user's intent (text prompt node, LoadAudio for audio-to-audio, etc.).
    • At least one output/save node wired to the final audio tensor (SaveAudioAdvanced or the partner node's own save output).

    SaveAudioAdvanced (display name "Save Audio (Advanced)") is the current save node, and it requires format alongside audio and filename_prefix — the older SaveAudio, SaveAudioMP3, and SaveAudioOpus classes are marked deprecated in the node catalog and are hidden from search_nodes.

    API-backed partner nodes often produce an audio tensor but do not include a save node by default — you must add one and wire it to their output. Without it the job runs successfully but produces nothing retrievable, wasting compute. Do not skip this check.

  5. Call submit_workflow with the workflow JSON.

  6. Poll get_job_status every 5 seconds until the job is completed. Show the user a brief status update while waiting. If the user asks to cancel, use cancel_job with the prompt_id.

  7. Call get_output to retrieve the generated audio. Pass a short description parameter (e.g. "ambient forest sounds") so the saved file gets a descriptive name.

  8. Tell the user where the audio file was saved and how to play it. Audio outputs are saved to disk but not previewed inline.

  9. If the user asked to BUILD or CREATE a workflow (not just for an output), after the run completes call save_workflow with the same JSON, a descriptive name, and overwrite: false — on a name collision choose a new name rather than replacing the user's existing workflow. Then call get_workflow_canvas_url with the workflow_id from the save result; if the save result omits workflow_id, find it with list_saved_workflows — never pass the filename (saved_workflow_filename publishes a PUBLIC share snapshot). If you ran a template with run_template, call get_template, apply the same input_overrides you ran with to that body (same node ids or slot paths; inputs you did not override keep the template defaults), and save_workflow the result instead, so the canvas matches the run. If you adjusted the run with submit_workflow + from_prompt_id reruns, apply each rerun's input_overrides on top, in run order, to whichever JSON you save (the built workflow or the template body), so the saved workflow matches the latest run rather than the first one. Give the user the canvas link. Mention that the saved layout is auto-generated and may need tidying. If you ran a subgraph template instead, tell the user the canvas shows one collapsed subgraph node and how to open it (double-click the node body, not its title, to step inside it, or right-click it and choose Unpack Subgraph to flatten it onto the canvas).

  10. If the user asks to adjust the result (different seed, prompt wording, steps/cfg, resolution, a different reference image) rather than a new subject: do NOT rebuild the workflow and do NOT re-send the JSON. Call submit_workflow with from_prompt_id set to the prompt_id of the run being adjusted and input_overrides holding ONLY the changed inputs ({nodeId: {inputName: value}}). If you do not know the node id, call get_job_status with include_workflow: true on that prompt_id first. A new reference image still goes through upload_file first; override the loader node's input with the returned filename. Then continue from step 6. If the result came from Step 0's partner_generate rather than a submitted workflow, there is no workflow to rerun: call partner_generate again with the changed fields. If the user wants the AUDIO itself edited (e.g. "keep this exact clip, just add an echo") rather than the workflow's inputs changed, call use_previous_output with that prompt_id (and output_index if it is not the first file), then feed the returned filename to a LoadAudio node in a submit_workflow graph — or into a template's audio slot via slot_overrides — that applies the edit. partner_generate medias[] accepts images only, so do not send a clip through it.

If any step fails, show the error clearly. Audio generation support in ComfyUI is newer than image generation, so fewer templates and models may be available.

Generate, edit, or modify an image using Comfy Cloud based on the user's description: $ARGUMENTS

Follow these steps exactly:

Step 0 — Route partner-API requests directly. If the user named a provider, model, or capability (e.g. "Flux Pro Ultra", "Nano Banana", "Kling", "DALL-E"), do one search_nodes lookup with the named term. partner_generate returns only the output, never a workflow: if the user asked to BUILD or CREATE a workflow (not just for an output), skip partner_generate and continue to Step 1, wiring the matching node into the workflow you build if its category starts with partner/ (an OSS match takes the normal steps below). If the matching node's category starts with partner/, try partner_generate first — its description names providers, not model ids, so pass type: "image" plus your best-guess model slug (a wrong one rejects before queuing and bounces back naming the closest real slugs, Did you mean: …), prompt, and any optional fields (aspect_ratio/seed/medias[]). On a bounce, first look for a run_template the bounce names (a "served by the bundled template … Do not retry this slug" reply): run that template instead of re-calling. Otherwise re-call once with the suggested slug only if it keeps the provider prefix of your guess (a kling/… suggestion for a kling/… guess) AND names the same product and shape the user asked for — a text-to-video slug is not a retry for an image-, reference- or first/last-frame-to-video request (-t2v for -i2v/-r2v/-flf2v), and a sound-effects slug is not a retry for speech; for those, find the family's own api_* template with search_templates and run_template it, or ask. If the bounce lists several slugs or several params.model tiers, pick the one that matches the user's request; if none clearly does, ask instead of re-calling (the re-call is the call that queues and charges, and tiers are priced differently). Pass a tier-shaped guess as params: {"model": "<tier>"} on the slug the bounce names rather than re-calling the bare slug (that runs the entry's default tier at a different price). Say which slug or tier you switched to. If that re-call bounces too, do not re-call again — handle it as "unknown model" with no close match named (below). The suggestions are ranked by token overlap across the whole registry, so one can belong to a provider the user never named — if none keeps your guess's provider prefix, do not re-call (the re-call is the call that queues and charges): stop and ask the user which model to use; inside submit_batch resend only the bounced item — its siblings may already be queued and charged. On success, return the artifact URL(s) and stop — do NOT continue with the workflow steps below. If partner_generate returns "unknown model" with no close match named, or "not yet implemented", or the matching node has no partner/ prefix (OSS model), continue to Step 1.

  1. Use search_templates to find a pre-built workflow template that matches the request (e.g. "text to image", "image to video", "style transfer", "inpainting"). If a good template exists, use it as the base workflow instead of building from scratch.

  2. If no suitable template was found, use search_models to find an appropriate checkpoint model for the request. Pick the best match based on the user's description (e.g. realistic photo -> realistic checkpoint, anime -> anime checkpoint, SDXL for high quality).

  3. If the user provides an input image (for img2img, style transfer, upscaling, etc.), use upload_file to upload it to Comfy Cloud first. Use the returned filename in a LoadImage node.

  4. Build a ComfyUI API-format workflow JSON with the appropriate nodes (or use the template workflow). A standard text-to-image workflow uses: CheckpointLoaderSimple, CLIPTextEncode (positive and negative prompts), EmptyLatentImage, KSampler, VAEDecode, SaveImage. For img2img, replace EmptyLatentImage with LoadImage + VAEEncode. Give EVERY node a _meta.title that names its role in plain words (e.g. "Load driving video", "Remove background", "Overlay graphic 1", "Save video"). The canvas shows these titles; without them the user sees only class names.

  5. Validate the workflow has inputs and outputs before submitting. Confirm the JSON contains:

    • At least one input node carrying the user's intent (CLIPTextEncode for prompts, LoadImage for img2img/style transfer, etc.).
    • At least one output/save node wired to the final image tensor (SaveImage, PreviewImage, or the partner node's own save output).

    API-backed partner nodes (Nano Banana, Gemini, Flux Kontext, etc.) often produce an image tensor but do not include a save node by default — you must add one and wire it to their output. Without it the job runs successfully but produces nothing retrievable, wasting compute. Do not skip this check.

  6. Call submit_workflow with the workflow JSON.

  7. Poll get_job_status every 3 seconds until the job is completed. Show the user a brief status update while waiting. If the user asks to cancel, use cancel_job with the prompt_id.

  8. Call get_output to retrieve the generated image. Pass a short description parameter (e.g. "cat astronaut in space") so the output gets a descriptive name.

  9. Display the image to the user:

    • In GUI environments (Claude Desktop): the response includes an ARTIFACT_HTML: block — create an HTML artifact using that exact HTML so the image appears in the side panel. The file is also saved to disk.
    • In CLI/terminal environments (Claude Code, Cursor): the response contains a temporary signed GCS download URL, a suggested save path, and a ready-to-run curl command on its own line. Execute that curl command verbatim via your shell/Bash tool — do not reconstruct it from the raw URL, and do not re-quote, re-encode, or strip any query parameters. The signature lives in the query string (X-Goog-Signature= and related params), and any modification will invalidate the link and the download will fail. After the file is saved, open it with open (macOS), xdg-open (Linux), or start (Windows).
  10. If the user asked to BUILD or CREATE a workflow (not just for an output), after the run completes call save_workflow with the same JSON, a descriptive name, and overwrite: false — on a name collision choose a new name rather than replacing the user's existing workflow. Then call get_workflow_canvas_url with the workflow_id from the save result; if the save result omits workflow_id, find it with list_saved_workflows — never pass the filename (saved_workflow_filename publishes a PUBLIC share snapshot). If you ran a template with run_template, call get_template, apply the same input_overrides you ran with to that body (same node ids or slot paths; inputs you did not override keep the template defaults), and save_workflow the result instead, so the canvas matches the run. If you adjusted the run with submit_workflow + from_prompt_id reruns, apply each rerun's input_overrides on top, in run order, to whichever JSON you save (the built workflow or the template body), so the saved workflow matches the latest run rather than the first one. Give the user the canvas link. Mention that the saved layout is auto-generated and may need tidying. If you ran a subgraph template instead, tell the user the canvas shows one collapsed subgraph node and how to open it (double-click the node body, not its title, to step inside it, or right-click it and choose Unpack Subgraph to flatten it onto the canvas).

  11. If the user asks to adjust the result (different seed, prompt wording, steps/cfg, resolution, a different reference image) rather than a new subject: do NOT rebuild the workflow and do NOT re-send the JSON. Call submit_workflow with from_prompt_id set to the prompt_id of the run being adjusted and input_overrides holding ONLY the changed inputs ({nodeId: {inputName: value}}). If you do not know the node id, call get_job_status with include_workflow: true on that prompt_id first. A new reference image still goes through upload_file first; override the loader node's input with the returned filename. Then continue from step 7. If the result came from Step 0's partner_generate rather than a submitted workflow, there is no workflow to rerun: call partner_generate again with the changed fields. If the user wants the IMAGE itself edited (e.g. "keep this exact picture, just make it night-time") rather than the workflow's inputs changed, use use_previous_output / partner_generate medias[] instead.

If any step fails, show the error clearly and suggest what might have gone wrong (wrong model, invalid node configuration, etc.).

Generate, edit, or extend a video using Comfy Cloud based on the user's description: $ARGUMENTS

Follow these steps exactly:

Step 0 — Route the named model family. If the user named a provider, model, or capability (e.g. "Kling", "Veo", "Flux 3 Video", "Runway", "MiniMax"), check both routes before doing anything else — unless it is one of the retired families under Retired below (OpenAI Sora, Runway gen3a_turbo, gemini-omni-flash-preview): skip the lookups for those and go straight to that redirect, since a lookup can still surface their deprecated node. Otherwise: one search_nodes lookup with the named term (for the partner/API node), and one search_templates lookup with the family name (for an OSS template). Some families — MiniMax H3 is a current example — ship as BOTH OSS weights and a paid partner node under the same display title; others exist only as a partner node. Tell them apart by where the hit came from, not by one naming rule: TEMPLATE names carry the convention (video_* is the OSS template, api_* the paid API one), while node CLASS names are CamelCase on both routes and are told apart by category — a paid API node sits under partner/…, an OSS node under model/…. To list one route's nodes only, re-run search_nodes with category: "partner" or category: "model". Treat a single empty lookup as inconclusive: broaden the query (drop version numbers, try the bare family name) before concluding a route is absent.

  • Family exists only as partner/API (no matching video_* template; the hits are an api_* template and/or a node whose category starts with partner/): route directly. partner_generate returns only the output, never a workflow: if the user asked to BUILD or CREATE a workflow (not just for an output), skip partner_generate and continue to Step 1, wiring the matching partner node into the workflow you build. Try partner_generate first — its description names providers, not model ids, so pass type: "video" plus your best-guess model slug (a wrong one rejects before queuing and bounces back naming the closest real slugs, Did you mean: …), prompt, and any optional fields (aspect_ratio/seed/duration/medias[]). On a bounce, first look for a run_template the bounce names (a "served by the bundled template … Do not retry this slug" reply): run that template instead of re-calling. Otherwise re-call once with the suggested slug only if it keeps the provider prefix of your guess (a kling/… suggestion for a kling/… guess) AND names the same product and shape the user asked for — a text-to-video slug is not a retry for an image-, reference- or first/last-frame-to-video request (-t2v for -i2v/-r2v/-flf2v), and a sound-effects slug is not a retry for speech; for those, find the family's own api_* template with search_templates and run_template it, or ask. If the bounce lists several slugs or several params.model tiers, pick the one that matches the user's request; if none clearly does, ask instead of re-calling (the re-call is the call that queues and charges, and tiers are priced differently). Pass a tier-shaped guess as params: {"model": "<tier>"} on the slug the bounce names rather than re-calling the bare slug (that runs the entry's default tier at a different price). Say which slug or tier you switched to. If that re-call bounces too, do not re-call again — handle it as "unknown model" with no close match named (below). The suggestions are ranked by token overlap across the whole registry, so one can belong to a provider the user never named — if none keeps your guess's provider prefix, do not re-call (the re-call is the call that queues and charges): stop and ask the user which model to use; inside submit_batch resend only the bounced item — its siblings may already be queued and charged. Guessing costs one call, so do not skip the tool for want of a list. On success, return the artifact URL(s) and stop — do NOT continue with the workflow steps below. If partner_generate returns "unknown model" with no close match named, or "not yet implemented", continue to Step 1.
  • Family exists only as OSS (a matching video_* template or a node under a non-partner/ category, with no api_* template and no partner/ node hit — an api_* template is a paid hit and belongs to the bullet above, never here): continue to Step 1 using it. Don't guess a partner_generate slug for it.
  • Family exists as both OSS and partner/API: do NOT auto-route to the paid path. Tell the user both options exist — OSS (no partner/API fee, but running it still spends ordinary Comfy Cloud compute credits, and it's typically slower; it's only actually free of charge when the user runs it themselves on their own local ComfyUI install) vs. paid partner/API (fast, no local hardware concern, costs the partner's per-run price on top of compute) — and ask which they want, unless they already said which one (e.g. "the free version", "local", "OSS", or named a paid partner product explicitly) or one route is genuinely infeasible right now. "Free" there refers to the partner fee only: if they picked OSS meaning free, say plainly — before submitting — that running it here still spends ordinary Comfy Cloud compute credits, and that running it locally on their own ComfyUI is the only no-charge option. Once the route is chosen: partner/API continues as in the bullet above; OSS continues to Step 1 using the matching template.

Retired — redirect, don't route. As of 2026-09, three video families are still asked for by name after leaving their provider's API: OpenAI Sora (sora-2, sora-2-pro — OpenAI removes the Videos API and both aliases on 2026-09-24, and ComfyUI's OpenAIVideoSora2 node is already deprecated), Runway gen3a_turbo (removed from the Runway API 2026-07-30), and gemini-omni-flash-preview (deprecated 2026-09-30). Don't look up the retired name itself — discover its replacement instead. For a text-to-video request, call partner_generate with a video slug its own tool description currently lists (or that search_models({ source: "partner", q: "video" }) returns); as of 2026-09 that set included bfl/flux-3-video, veo/veo-3-t2v and kling/kling-v3-t2v. When the request carries input media, find the like-for-like workflow with search_templates (querying the successor family — "Flux 3 Video" for Sora, "Runway Gen4" for Runway, "Gemini Omni Flash" for Gemini) and run the api_* template it returns via run_template. If that query returns too much, narrow it with the task tag that matches the input — "Image to Video", "Video Edit", "Reference to Video" — never "video": these templates are tagged by task plus "API", so a "video" filter drops them. As of 2026-09 those were api_bfl_flux3_i2v, api_runway_gen4_turbo_image_to_video and api_google_gemini_omni_flash_1_1_i2v (or _t2v for a prompt) — use the names the live search returns, not these. Comfy Cloud answers these three names with the same redirect, so pass it on as a live alternative rather than as a dead end.

Never tell a user the OSS route doesn't exist for a family that has one — that's a wrong answer, not a cautious one.

  1. Use search_templates with relevant queries like "text to video", "image to video", or "video generation" to find a pre-built video workflow template. Filter by tag "video" if the text search returns too many image results. If a good template exists, use it as the base workflow instead of building from scratch.

  2. If no suitable template was found, use search_models to find an appropriate video model. Common video models include: LTX-Video, Wan Video, HunyuanVideo, AnimateDiff, CogVideoX. Pick the best match based on the user's description.

  3. If the user provides an input image (for image-to-video), use upload_file to upload it first. Use the returned filename in a LoadImage node.

  4. Build a ComfyUI API-format workflow JSON with the appropriate video nodes. Video workflows typically use specialized loader nodes (e.g. LTXVLoader, WanVideoModelLoader), video-specific samplers, and video output nodes (e.g. VHS_VideoCombine). If using a template, modify the prompt and settings as needed. Give EVERY node a _meta.title that names its role in plain words (e.g. "Load driving video", "Remove background", "Overlay graphic 1", "Save video"). The canvas shows these titles; without them the user sees only class names.

  5. Validate the workflow has inputs and outputs before submitting. Confirm the JSON contains:

    • At least one input node the user's intent flows through (CLIPTextEncode for the prompt, LoadImage for image-to-video, etc.).
    • At least one output/save node wired to the final video tensor (e.g. VHS_VideoCombine, SaveAnimatedWEBP, SaveVideo, or the partner node's own save output).

    API-backed partner nodes (Kling, Nano Banana, Gemini, Veo, etc.) often produce a video tensor but do not include a save node by default — you must add one and wire it to their output. Without it the job runs successfully but produces nothing retrievable, wasting compute. Do not skip this check.

  6. Call submit_workflow with the workflow JSON. Note: video generation typically takes longer than image generation (30s-2min+).

  7. Poll get_job_status every 5 seconds until the job is completed. Show the user a brief status update while waiting. Mention that video generation takes longer than images. If the user asks to cancel, use cancel_job with the prompt_id.

  8. Call get_output to retrieve the generated video. Pass a short description parameter (e.g. "cat running through field") so the saved file gets a descriptive name.

  9. Tell the user where the video file was saved and how to view it. Video outputs are saved to disk but not previewed inline.

  10. If the user asked to BUILD or CREATE a workflow (not just for an output), after the run completes call save_workflow with the same JSON, a descriptive name, and overwrite: false — on a name collision choose a new name rather than replacing the user's existing workflow. Then call get_workflow_canvas_url with the workflow_id from the save result; if the save result omits workflow_id, find it with list_saved_workflows — never pass the filename (saved_workflow_filename publishes a PUBLIC share snapshot). If you ran a template with run_template, call get_template, apply the same input_overrides you ran with to that body (same node ids or slot paths; inputs you did not override keep the template defaults), and save_workflow the result instead, so the canvas matches the run. If you adjusted the run with submit_workflow + from_prompt_id reruns, apply each rerun's input_overrides on top, in run order, to whichever JSON you save (the built workflow or the template body), so the saved workflow matches the latest run rather than the first one. Give the user the canvas link. Mention that the saved layout is auto-generated and may need tidying. If you ran a subgraph template instead, tell the user the canvas shows one collapsed subgraph node and how to open it (double-click the node body, not its title, to step inside it, or right-click it and choose Unpack Subgraph to flatten it onto the canvas).

  11. If the user asks to adjust the result (different seed, prompt wording, steps/cfg, resolution, a different reference image) rather than a new subject: do NOT rebuild the workflow and do NOT re-send the JSON. Call submit_workflow with from_prompt_id set to the prompt_id of the run being adjusted and input_overrides holding ONLY the changed inputs ({nodeId: {inputName: value}}). If you do not know the node id, call get_job_status with include_workflow: true on that prompt_id first. A new reference image still goes through upload_file first; override the loader node's input with the returned filename. Then continue from step 7. If the result came from Step 0's partner_generate rather than a submitted workflow, there is no workflow to rerun: call partner_generate again with the changed fields. If the user wants the VIDEO itself edited (e.g. "keep this exact clip, just make it night-time") rather than the workflow's inputs changed, call use_previous_output with that prompt_id (and output_index if it is not the first file), then feed the returned filename to a LoadVideo node (the core loader; VHS_LoadVideo if the template uses it) in a submit_workflow graph — or into a template's video slot via slot_overrides — that applies the edit. partner_generate medias[] accepts images only, so do not send a clip through it.

If any step fails, show the error clearly. Common video generation issues: model not available on cloud, insufficient GPU memory for long videos, unsupported video length.

Model notes: MiniMax H3 (as of 2026-08)

Model facts change over time. The following was accurate as of 2026-08 — confirm current details with search_templates, search_nodes, and get_node rather than assuming they still hold.

  • H3 is the current best open-source video model (tier 0), on par with closed-source SOTA models like Seedance 2.x. If a user wants the best open-source video model and doesn't name one, recommend H3.
  • As of 2026-08, H3 ships with two routes: OSS weights and a paid partner/API node — confirm both are currently live with search_templates/search_nodes rather than assuming this holds forever. OSS carries no partner/API fee, but running it on Comfy Cloud still spends ordinary Comfy Cloud compute credits — it's only free of charge outright when the user runs it locally on their own ComfyUI install. Don't conclude the OSS route is gone from one empty or ambiguous lookup; broaden the search before telling a user there's no OSS option, and don't let that session-local evidence override what a fresh, authoritative lookup says either.
  • As of 2026-08, both routes share the same display title, "MiniMax H3: Text to Video" (and the image-to-video variant), told apart by internal name: video_minimax_h3_* is OSS, api_minimax_h3_* is the paid API node. Confirm the current prefix with search_nodes/get_node before relying on it — naming can change. A search_nodes call with exclude_api=True also isolates the OSS node in the current catalog.
  • Before building the OSS workflow, ask about the user's hardware and set expectations from it. Dynamic VRAM offloading widens what a GPU can attempt, but it is not a guarantee — out-of-memory is still possible, and actual headroom depends on resolution, duration, VRAM, and system RAM together, not VRAM alone:
    • Tested comfortable range (as of 2026-08): a 30-series-or-newer GPU with 16+ GB VRAM and enough system RAM that offloaded weights don't starve the host.
    • Reference benchmarks on the basic workflow, same date: 5 seconds at 480p takes about 9 minutes on a 3060; about 15 minutes for 5 seconds on a 16 GB card. Below the tested range, OOM becomes more likely — if it happens, suggest a lower resolution or shorter duration rather than assuming the run will simply succeed slower.
    • Generation time scales exponentially with pixel count, not linearly. Re-estimate for the resolution the user actually wants — don't scale the numbers above linearly.
    • Quote the estimate before running so a user on a weak GPU can decide with full information. Slow is not the same as impossible, but OOM is a real outcome on undersized hardware — don't promise success on every GPU.
  • Model files: use the int8 base model on all GPUs, including 50-series cards, and the NVFP4 text encoder on all GPUs. The official template's default file choices are correct for nearly every GPU — don't second-guess them without a specific reason.
  • The partner/API node's resolution and duration options are that node's dropdown, not necessarily the model's full real limits. Treat the numbers below as the 2026-08 reference point and confirm current ones with get_node on the OSS node before enforcing a hard cutoff:
    • As of 2026-08: OSS accepts any resolution in multiples of 32, up to about 2K.
    • As of 2026-08: OSS duration follows a 17k+5-frame grid at 24fps (k = 0, 1, 2, ...), up to about 15 seconds max.
    • As of 2026-08: OSS has native stereo audio.
    • If the user asks for something outside the API node's presets (e.g. exactly 1000x1000), don't call it impossible before checking — the OSS node's actual schema (via get_node) may still support it.
    • For production-quality output, suggest generating at the native ~768p canvas and upscaling afterward, rather than requesting a large canvas directly.
  • Evidence beats assumption, but keep it scoped: if you already ran OSS H3 successfully, or a tool call already showed the model files present, treat that as proof the OSS route exists for this request — don't contradict it later in the same turn because of an unrelated error. That said, this doesn't override a fresh, authoritative search_templates/search_nodes result — if a live lookup says the OSS route isn't currently available, trust the live result over older evidence.
  • hailuo (the alias partner_generate uses) is the older MiniMax Hailuo family, not H3. Don't mix Hailuo's parameters into an H3 request. That said, a user who says "Hailuo 03" most likely means H3 — confirm rather than assuming they want the old Hailuo family.
  • The OSS image-to-video template ships with one helper node left disconnected on purpose, and validation will flag it. That's expected: after fetching the template, validate, then either prune the disconnected helper pair or wire an IMAGE link into it, and proceed. Don't treat that validation failure as a dead end.
  • Speed-up, OSS route: if the user asks for faster H3, the default answer is ONE change — flip the shipped template's Boolean (Enable Lightning LoRA) switch (default off in video_minimax_h3_t2v / _i2v / _r2v). As of 2026-08 it swaps in the 8-step turbo LoRA and drops steps from 20 to 6 (R2V: 4) at the model's default sigma shift, trading slightly weaker audio and motion for roughly 3x fewer sampler steps. Offer the next rungs only when that is not enough, in this order: (2) the video_fastvideo_fasth3_t2v / _i2v templates (separate FastH3 8-step checkpoint, shift 10/3 pre-wired, no R2V variant); (3) the 768p 4-step LoRA at 4 steps with an explicit MiniMaxH3SigmaShift 6/3; (4) fewer pixels or a shorter duration. The paid api_minimax_h3_max_turbo_* templates are the fastest route (768p in roughly 1-3 s; launch them with run_template) but add partner fees, so present them as a route change under the OSS-vs-partner rule above rather than picking them silently. Template names, step counts and shifts here are the 2026-08 values: confirm the template with search_templates and read the switch and step values from the fetched graph before changing them, and confirm the paid templates' current availability and price before offering them. Say which rung you chose and why instead of listing all of them.

Show the user what they can do with the ComfyUI Cloud MCP tools.

Explain in a friendly, concise way:

What you can do:

  • Generate images from text descriptions -- just describe what you want
  • Upload input images for img2img, style transfer, or any workflow that needs a source image
  • Search for models (checkpoints, LoRAs, VAEs, upscalers) available on Comfy Cloud
  • Search for ComfyUI nodes to discover processing capabilities
  • Build and run complex multi-step workflows (img2img, upscaling, style transfer)
  • Refine a previous result without rebuilding it (rerun with changed inputs)
  • Cancel running or queued jobs if you change your mind
  • Check queue status to see how busy the system is

Quick examples to try:

  • "Generate a photo of a mountain lake at golden hour"
  • "Search for anime-style checkpoint models"
  • "What upscaling nodes are available?"
  • "Generate an image of a robot, then upscale it 2x"
  • "Upload this photo and turn it into a watercolor painting"
  • "Cancel that last job"

How it works: The ComfyUI Cloud MCP server connects to cloud.comfy.org. Workflows run on cloud GPUs so you don't need a local GPU. I can build ComfyUI workflows automatically from your descriptions.

Tips:

  • Be descriptive in your prompts for better results
  • Mention a style if you want something specific (photorealistic, anime, oil painting, etc.)
  • You can ask me to search for specific model types if you know what you need
  • After generating, I can save and open the image for you

Remove the background from an image using Comfy Cloud: $ARGUMENTS

Follow these steps exactly:

  1. Use search_templates with queries like "remove background", "background removal", or "transparent background" to find a pre-built background removal workflow template. If a good template exists, use it as the base workflow instead of building from scratch.

  2. If no suitable template was found, use search_nodes to find background removal nodes. Search for "RMBG", "background removal", "SAM", or "segment". Common nodes: RMBG (fast automatic removal), SAM (segment anything for precise masks), BiRefNet (high-quality matting).

  3. The user must provide an input image. Use upload_file to upload it to Comfy Cloud. Use the returned filename in a LoadImage node.

  4. Build a ComfyUI API-format workflow JSON for background removal. A typical workflow uses: LoadImage → background removal node (e.g. RMBG) → SaveImage (with PNG format to preserve transparency). If the user wants to replace the background rather than make it transparent, add a second image and composite them. Give EVERY node a _meta.title that names its role in plain words (e.g. "Load driving video", "Remove background", "Overlay graphic 1", "Save video"). The canvas shows these titles; without them the user sees only class names.

  5. Validate the workflow has inputs and outputs before submitting. Confirm the JSON contains:

    • At least one input node (LoadImage for the source image).
    • At least one output/save node wired to the final image (SaveImage with PNG format to preserve transparency).

    Without an output node the job runs successfully but produces nothing retrievable, wasting compute. Do not skip this check.

  6. Call submit_workflow with the workflow JSON.

  7. Poll get_job_status every 3 seconds until the job is completed. Show the user a brief status update while waiting. If the user asks to cancel, use cancel_job with the prompt_id.

  8. Call get_output to retrieve the result. Pass a short description parameter (e.g. "transparent-portrait") so the suggested filename is descriptive, then run the returned curl command in the user's shell to download the file.

  9. Display the result to the user. Note that the output is a PNG with transparency if background was removed (not replaced).

  10. If the user asked to BUILD or CREATE a workflow (not just for an output), after the run completes call save_workflow with the same JSON, a descriptive name, and overwrite: false — on a name collision choose a new name rather than replacing the user's existing workflow. Then call get_workflow_canvas_url with the workflow_id from the save result; if the save result omits workflow_id, find it with list_saved_workflows — never pass the filename (saved_workflow_filename publishes a PUBLIC share snapshot). If you ran a template with run_template, call get_template, apply the same input_overrides you ran with to that body (same node ids or slot paths; inputs you did not override keep the template defaults), and save_workflow the result instead, so the canvas matches the run. If you adjusted the run with submit_workflow + from_prompt_id reruns, apply each rerun's input_overrides on top, in run order, to whichever JSON you save (the built workflow or the template body), so the saved workflow matches the latest run rather than the first one. Give the user the canvas link. Mention that the saved layout is auto-generated and may need tidying. If you ran a subgraph template instead, tell the user the canvas shows one collapsed subgraph node and how to open it (double-click the node body, not its title, to step inside it, or right-click it and choose Unpack Subgraph to flatten it onto the canvas).

  11. If the user asks for a different strength/model (e.g. a different removal model or mask threshold), rerun via submit_workflow with from_prompt_id set to the prompt_id of the run being adjusted and input_overrides holding ONLY the changed inputs ({nodeId: {inputName: value}}); do not re-upload the source and do not rebuild the workflow. If you do not know the node id, call get_job_status with include_workflow: true on that prompt_id first. Then continue from step 7.

If any step fails, show the error clearly. If background removal nodes aren't available, suggest using an inpainting approach as a fallback.

Search for ComfyUI models available on Comfy Cloud: $ARGUMENTS

Use search_models to find models matching the user's query. If they didn't specify filters, search by text. If they mentioned a type (checkpoint, lora, vae, controlnet, upscaler), filter by type. If they mentioned a base model (SD 1.5, SDXL, Flux), filter by base_model.

Present the results in a clean table format:

  • Model name
  • Type
  • Base model (if available)
  • Source (huggingface/civitai)

If there are many results, show the top 10 and mention the total count.

Search for ComfyUI nodes available on Comfy Cloud: $ARGUMENTS

Use search_nodes to find nodes matching the user's query. If they asked about a category (image processing, sampling, conditioning), filter by category. If they asked about I/O types (IMAGE, LATENT, MODEL), filter by input_type or output_type.

Present the results clearly:

  • Node name and display name
  • Category
  • Pack (which custom node pack it belongs to, or "core" for built-in)
  • Inputs and outputs

If they're looking for nodes to accomplish a specific task, suggest which nodes to use together and how to wire them up.

Search for ComfyUI workflow templates available on Comfy Cloud: $ARGUMENTS

Use search_templates to find pre-built workflow templates matching the user's query. Templates are ready-to-use workflows from comfy.org that can be deployed directly to Comfy Cloud.

Search strategies:

  • If the user describes a task (e.g. "generate a video from an image"), search by text query
  • If they mention a category (e.g. "text to image", "video"), filter by tag
  • If they mention a specific model (e.g. "Flux", "LTX", "SDXL"), filter by model

Present the results in a clean format:

  • Template title
  • Description (first sentence)
  • Tags
  • Models used
  • URL to view/deploy

If there are many results, show the top 10 and mention the total count.

Upscale an image using Comfy Cloud: $ARGUMENTS

Follow these steps exactly:

  1. Use search_templates with queries like "upscale", "super resolution", or "image upscaler" to find a pre-built upscaling workflow template. If a good template exists, use it as the base workflow instead of building from scratch.

  2. If no suitable template was found, use search_models with type "upscale_models" to find an appropriate upscaler model. Popular options: 4x-UltraSharp (general purpose), RealESRGAN_x4plus (photorealistic), RealESRGAN_x4plus_anime_6B (anime/illustration), 4x_NMKD-Siax_200k (balanced). For 2x upscale, look for 2x models.

  3. The user must provide an input image. Use upload_file to upload it to Comfy Cloud. Use the returned filename in a LoadImage node.

  4. Build a ComfyUI API-format workflow JSON for upscaling. A standard upscale workflow uses: LoadImage → UpscaleModelLoader → ImageUpscaleWithModel → SaveImage. For higher quality results with more control, you can use a two-pass approach: upscale first, then run through img2img with a checkpoint at low denoise (0.2-0.4) to add detail. Give EVERY node a _meta.title that names its role in plain words (e.g. "Load driving video", "Remove background", "Overlay graphic 1", "Save video"). The canvas shows these titles; without them the user sees only class names.

  5. Validate the workflow has inputs and outputs before submitting. Confirm the JSON contains:

    • At least one input node (LoadImage for the source image).
    • At least one output/save node wired to the upscaled image (SaveImage, or the partner node's own save output).

    Without an output node the job runs successfully but produces nothing retrievable, wasting compute. Do not skip this check.

  6. Call submit_workflow with the workflow JSON.

  7. Poll get_job_status every 3 seconds until the job is completed. Show the user a brief status update while waiting. If the user asks to cancel, use cancel_job with the prompt_id.

  8. Call get_output to retrieve the upscaled image. Pass a short description parameter (e.g. "upscaled-photo") so the suggested filename is descriptive, then run the returned curl command in the user's shell to download the file.

  9. Display the result to the user. Mention the output resolution compared to the input if known.

  10. If the user asked to BUILD or CREATE a workflow (not just for an output), after the run completes call save_workflow with the same JSON, a descriptive name, and overwrite: false — on a name collision choose a new name rather than replacing the user's existing workflow. Then call get_workflow_canvas_url with the workflow_id from the save result; if the save result omits workflow_id, find it with list_saved_workflows — never pass the filename (saved_workflow_filename publishes a PUBLIC share snapshot). If you ran a template with run_template, call get_template, apply the same input_overrides you ran with to that body (same node ids or slot paths; inputs you did not override keep the template defaults), and save_workflow the result instead, so the canvas matches the run. If you adjusted the run with submit_workflow + from_prompt_id reruns, apply each rerun's input_overrides on top, in run order, to whichever JSON you save (the built workflow or the template body), so the saved workflow matches the latest run rather than the first one. Give the user the canvas link. Mention that the saved layout is auto-generated and may need tidying. If you ran a subgraph template instead, tell the user the canvas shows one collapsed subgraph node and how to open it (double-click the node body, not its title, to step inside it, or right-click it and choose Unpack Subgraph to flatten it onto the canvas).

  11. If the user asks for a different strength/model (e.g. a different upscaler model or scale factor), rerun via submit_workflow with from_prompt_id set to the prompt_id of the run being adjusted and input_overrides holding ONLY the changed inputs ({nodeId: {inputName: value}}); do not re-upload the source and do not rebuild the workflow. If you do not know the node id, call get_job_status with include_workflow: true on that prompt_id first. Then continue from step 7.

If any step fails, show the error clearly. Common issues: input image too large for GPU memory (suggest downscaling first or using a tile-based upscaler like UltimateSDUpscale).

MCP servers 1

Sponsors

Details

Marketplace
Comfy-Org/comfy-skills
Source
claude-code
Category
Community

More from Comfy-Org/comfy-skills

All 2