Your first ComfyUI image looks promising. The composition works, the lighting fits the brief, and the style is close. Then you adjust the prompt and run it again. The subject shifts, a detail disappears, and you are no longer sure which change improved the result.

Using Claude with ComfyUI can make that experimentation more structured. Instead of only asking Claude to write prompts, you can connect it through Comfy MCP to inspect the available tools, work with workflow files, submit generations, follow jobs, and retrieve outputs. The connection provides access to ComfyUI; it does not give Claude unlimited control or additional GPU memory.

Computer Use adds a visual interaction route. In a supported desktop setup, Claude can navigate the permitted browser or application, inspect the node canvas, and help compare generated images. Reading a workflow and reviewing its visible results serve different purposes.

The useful goal is not endless automatic generation. It is a controlled loop: start with a working graph, change specified parameters, review the results, and preserve the settings behind the image you choose. This guide builds that workflow step by step.

Source: ComfyUI Documentation

Start With a Workflow That Already Runs

Before connecting Claude, run a small generation yourself. That establishes whether ComfyUI, the required models, and your hardware can execute the workflow. Otherwise, the first conversation may become an installation troubleshooting session rather than a useful experiment.

For this guide, start with a simple checkpoint-based text-to-image workflow. Its basic path loads a checkpoint, encodes text conditioning, samples a latent image, decodes it through a VAE, and saves the result. Other model families can require different loaders, encoders, and sampling arrangements, so this graph is an example, not a universal template.

Source: ComfyUI Documentation

Use a clear brief, such as a studio product image with space for headline text. Generate one image at a resolution appropriate for the selected model and available memory.

Record the selected model, prompt, seed, resolution, and sampling settings. Also note any custom nodes. These details give Claude a concrete baseline instead of forcing it to infer your environment from a screenshot.

Save a separate copy of the working workflow before requesting changes. Keep the original unchanged so you can compare results and recover if an experiment breaks the graph.

Do not add an upscaler, several LoRAs, and unfamiliar custom nodes just to make the starting point more sophisticated. A compact workflow makes it easier to identify which change affects the image and which change causes a failure.

Connect Claude to the ComfyUI Instance You Actually Use

Use the official Comfy MCP server for the main connection. It documents Claude Desktop support and works through comfy-cli, which manages the ComfyUI workspace and executes the underlying operations.

For the initial setup, keep Claude Desktop, the MCP server, and ComfyUI on the same computer. Remote configurations are possible, but introduce additional questions about network access, file locations, and which machine each tool operates on.

Install the connection components

In a suitable Python environment, install the server and its required CLI engine:

This command installs the connection components, not your models. If you already have a working ComfyUI installation, do not create another workspace unnecessarily. Point comfy-cli at the existing installation:

Confirm that this is the workspace containing the models, custom nodes, and baseline workflow you tested. Launch ComfyUI through your usual method or the documented comfy launch command, then leave it running.

Add the server to Claude Desktop

The repository documents configuration through Claude Desktop’s developer settings. Open Settings → Developer → Edit Config and add an entry to claude_desktop_config.json:

Replace both paths with the executables installed in your environment. Windows paths need JSON-compatible escaping. Preserve existing MCP entries rather than replacing the configuration file’s contents.

Restart Claude Desktop and check that the server’s tools appear. An API key is not required merely to run ordinary local model workflows; partner API nodes have separate authentication and spending requirements.

Verify the target before generating

Start with a read-only request:

Inspect the connected ComfyUI environment. Report the target server, workspace information available to you, installed models, and whether the baseline workflow’s required node classes are present. Do not generate images, download models, install nodes, restart ComfyUI, or modify files.

Compare Claude’s findings with your working installation. A successful MCP handshake alone does not establish that the CLI engine is available or that the correct workspace is selected.

Local versus cloud: Comfy Cloud MCP is a separate remote connection that executes workflows on Comfy Cloud infrastructure. Do not mix its configuration or credentials with this local setup.

Finally, MCP access does not automatically enable Computer Use. Browser and screen interaction require their own supported environment and permissions.

Source: ComfyUI Documentation

Ask Claude to Explain the Graph Before Changing It

Once the connection works, give Claude the saved baseline workflow and ask it to explain the generation path. Do not begin with “optimize this workflow.” First establish which nodes contribute to the final image and which settings they control.

A useful request is:

Inspect this workflow without editing or running it. Trace the path from model loading and text conditioning through sampling, decoding, and image saving. Identify the node IDs, model references, image dimensions, seed, sampling settings, and output filename prefix. Report missing dependencies and anything you cannot verify.

Source: ComfyUI Documentation

Separate the editable graph from the execution graph

ComfyUI workflows can be represented in different JSON formats. A UI workflow includes information needed to reconstruct the editor, such as node positions, connections, and widget values. An API-format graph describes the nodes and inputs needed for execution.

An API node entry may look like this:

{
  "6": {
    "class_type": "CLIPTextEncode",
    "inputs": {
      "text": "Studio product photograph",
      "clip": ["4", 1]

{
  "6": {
    "class_type": "CLIPTextEncode",
    "inputs": {
      "text": "Studio product photograph",
      "clip": ["4", 1]

Here, "6" is the node ID. class_type identifies the node implementation, while ["4", 1] references output index 1 from node "4". These IDs are illustrative; Claude must read your actual graph rather than assume its numbering.

The official Comfy MCP server documents support for API-format workflows and UI exports. That does not mean every connector handles both formats or synchronizes changes with the graph currently open in your browser.

Check dependencies against the installed environment

Ask Claude to compare the graph’s node classes and model references with what ComfyUI actually exposes. ComfyUI’s server API provides node information through /object_info; the connector can make supported discovery operations available as tools.

A node label alone does not establish compatibility. A similarly named loader may expect a different model type, and an installed custom-node package may fail to load because a dependency is missing.

Finish with a short graph summary and an explicit list of proposed changes. Keep the baseline untouched until you approve that plan.

Turn “Make It Better” Into a Controlled Experiment

With the baseline explained, turn the creative brief into a bounded experiment. “Make this product image better” could lead Claude to change the prompt, model, resolution, and sampling settings simultaneously. Even if the result improves, you would not know which adjustment helped.

For our studio image, define what success means: the product remains recognizable, the background leaves space for a headline, and the lighting does not obscure important details. Keep text generation outside the experiment unless lettering is part of the brief.

Change one variable group at a time

Ask Claude to propose three variations before submitting any jobs:

Prepare three experiments from the saved baseline workflow. First change only the prompt’s composition instructions. Then test one supported sampling parameter against the baseline. Finally, propose a style adjustment using existing compatible resources. List every changed node ID and value. Do not run anything until I approve the plan.

Use a small experiment table to make the comparison explicit:

Each variant should branch from the baseline, not silently inherit the previous experiment’s changes. Otherwise, the comparison becomes cumulative and harder to interpret.

Choose parameters that exist in the selected workflow and make sense for its model. Settings such as guidance strength, sampler, or denoising do not behave identically across every pipeline.

Source: ComfyUI Documentation

Control seeds and generation count

Keep the seed fixed during the initial comparison and check whether the workflow’s seed control automatically increments or randomizes after execution. Record the value actually used, not just the number visible before queuing.

A fixed seed helps organize comparisons, but it does not guarantee identical images across different models, software versions, hardware, or execution settings. Changing a parameter can also affect how closely the resulting composition resembles the baseline.

Start with one image per approved variant. If a direction looks promising, authorize a small additional seed set to see whether the improvement holds beyond one result. Avoid judging an entire approach from a single lucky generation.

Source: ComfyUI Documentation

Put a boundary around execution

The Comfy MCP tools can run workflows and retrieve results, but tool access should not become permission for unlimited experimentation.

Specify the maximum number of jobs, output directory, and prohibited actions. Model downloads, custom-node installations, and paid partner API calls require separate approval. A locally executed graph can still contain nodes that contact external services.

Save each modified workflow with a distinct name and record its job ID. That gives the next review stage a traceable connection between the proposed change, the executed graph, and the generated image.

Use Computer Use for Canvas Inspection and Visual Review

A workflow can execute successfully while producing an image that misses the brief. The product may sit too close to the frame edge, the intended headline space may be cluttered, or the lighting may hide a defining feature. These are reasons to inspect the result, not automatically add more nodes.

Claude’s Computer Use provides a visual interaction route in supported desktop environments. Enable it and approve access to the relevant browser or application. MCP access alone does not grant that permission.

Inspect the canvas with a specific question

Use the MCP connection for available graph data and repeatable operations. Use visual interaction when you need Claude to examine how the workflow appears in the editor.

For example, ask Claude to navigate to the sampling group, inspect visible widget values, or check the preview of an input image or mask. Keep the task narrow:

Inspect the workflow open in ComfyUI. Locate the sampling and output groups, then compare their visible settings with the approved experiment record. Do not change connections, edit values, or queue a generation. Report any mismatch.

This can reveal that the browser still displays the baseline while the MCP server executed a modified workflow file. Do not assume those two states are synchronized.

Source: ComfyUI Documentation

Compare outputs under consistent conditions

Open the baseline and variants at the same display scale. Use the complete image for composition review, then inspect important areas more closely. A small preview may conceal artifacts, while different zoom levels can make sharpness comparisons misleading.

Give Claude concrete review criteria:

Compare these outputs against the brief. Assess product visibility, space for a headline, background distractions, and obvious visual artifacts. Identify each image by its filename. Separate visible observations from technical properties you cannot verify, and do not generate replacements.

Claude can help organize observations, but aesthetic preference and brand accuracy still need your judgment. It may also overlook small defects or interpret an intentional feature as an error.

Turn feedback into the next experiment

A useful review ends with a proposed change, not an unrestricted rerun. “Variant A leaves more usable headline space, but the highlight obscures the front edge” is actionable. “Improve everything” is not.

These are proposed workflows, not claims that Claude will reliably complete every canvas operation. ComfyUI is browser-based, so Claude may use browser tools where available rather than screen-level clicks. Also, receiving an output image through MCP is visual input, but it is not itself Computer Use.

Follow the Job, Not Just the Queue Button

Submitting a workflow starts a process; it does not prove that an image has been generated. The job may be waiting behind another task, executing a slow node, or failing before it reaches the output stage.

ComfyUI’s server API separates submission, queue inspection, history, and output retrieval. The MCP connector wraps supported operations so Claude can follow a generation without repeatedly clicking the interface.

Keep the job ID attached to the experiment

Record the prompt_id returned when the workflow is submitted. Associate it with the variant name and saved workflow file.

An empty queue does not establish success. Check the job’s history or reported result for errors and outputs.

Use a bounded instruction:

Submit the approved variant once. Record its job ID and monitor that job until it completes or fails. If waiting times out, report the current status without submitting a duplicate. Retrieve the expected output files only after completion.

Source: ComfyUI Documentation

Treat a timeout as uncertainty, not permission to retry

A connector’s waiting period can expire while ComfyUI continues working. Ask Claude to query the existing job before deciding whether another submission is necessary. WebSocket execution messages can provide progress and error information where the integration exposes them.

Cancellation needs care too. ComfyUI’s raw interrupt operation is not equivalent to safely canceling any named job. Verify the connector’s cancellation behavior and which task is currently running, particularly on a shared instance.

Finally, match retrieved files to the correct job. A filename that looks plausible is not enough to identify the experiment.

Diagnose Missing Nodes, Model Mismatches, and VRAM Errors

When an experiment fails, preserve the workflow and identify the failing node before changing anything else. Rewriting the prompt will not resolve a missing model file, and installing more custom nodes can make a dependency problem harder to diagnose.

Ask Claude for a focused failure report:

Inspect the failed job and its logs. Report the node ID, node class, error message, and relevant model references. Propose the smallest corrective step. Do not install packages, download models, change the workflow, or resubmit it without approval.

The ComfyUI model troubleshooting guide helps distinguish missing files from incompatible model components. A model being selectable does not establish that it belongs in the current pipeline.

For memory failures, change one factor at a time. A smaller batch or lower resolution may help, but neither guarantees that the model itself fits.

Avoid “update everything” as the first response. Review custom-node code and dependencies before installation. After an approved fix, rerun the smallest useful test and keep the original failure record.

Source: ComfyUI Documentation

Save the Experiment, Not Just the Winning Image

The selected image is only part of the deliverable. If you save the PNG but lose its workflow, inputs, and settings, the next revision may become another round of guesswork.

Ask Claude to assemble a small experiment package in an approved directory:

Keep the editable workflow export where possible, not just the API execution graph. Browser layout information can make later manual review easier.

Source: ComfyUI Documentation

Build a review sheet with traceable labels

A useful extra task is asking Claude to create a contact sheet or simple HTML comparison page. Each image should include its variant name and a short description of what changed.

Create a comparison page from the approved output files. Label each image with its filename, experiment name, seed, and changed settings from the run record. Mark unavailable information as unknown. Do not generate additional images or publish the page.

This is an additional deliverable Claude can prepare, not a built-in ComfyUI feature. Ensure the labels come from recorded data rather than guesses about the images.

Remove credentials and private paths before sharing the package. Check permissions for reference assets and model licenses separately. Preserved settings improve traceability, but they do not guarantee identical output on another installation.

Give Your ComfyUI Workflows More GPU Headroom With Vagon

Claude can organize experiments, but it cannot give your GPU more memory. Larger models, higher resolutions, and additional processing stages still need hardware capable of carrying the workload. When your laptop becomes the bottleneck, Vagon Cloud Computer offers a way to access GPU resources without buying another workstation.

Run ComfyUI on a cloud computer, keep your models and workflows organized, and choose a performance option suited to your actual generation pipeline. GPU memory matters, but so do system RAM, storage capacity, and the time needed to load large model files.

Vagon’s ComfyUI setup guide covers a GPU Ubuntu desktop. Keep the Claude environment separate in your planning: running ComfyUI on Ubuntu does not mean Claude Desktop runs there too. Use a supported Claude desktop environment and a deliberately configured connection to the generation machine. Verify which MCP tools operate remotely and which still use the client machine’s files or installation.

Start with a representative test before queuing a large experiment. Generate previews at sensible dimensions, review them, then upscale only the selected results. More VRAM creates headroom; it does not guarantee that every model or custom-node combination will work.

Ready to move beyond your local GPU’s limits? Explore Vagon’s performance options, test your workflow, and scale resources around the work you need to complete. Stop unused compute while accounting for ongoing storage costs.

FAQs

Can Claude generate images through ComfyUI?

Yes, with a compatible MCP connection. Claude can submit supported workflows, monitor jobs, and retrieve outputs. ComfyUI and the selected models perform the generation; Claude helps coordinate the process and interpret results.

Do I need Claude Code, or can I use Claude Desktop?

The official Comfy MCP project documents both clients. Claude Desktop can connect to the local server without requiring Claude Code. Computer Use has separate availability and permission requirements, so verify those before planning interface-based tasks.

Can Claude modify the workflow open in my browser?

It depends on the integration. Editing a saved workflow file through MCP does not necessarily update the visible canvas. A live-editor integration or permitted browser interaction may provide that capability. Confirm which graph will actually execute before queuing.

What is the difference between local Comfy MCP and Comfy Cloud MCP?

They target different execution environments. Local Comfy MCP works with your ComfyUI installation or supported remote configuration. Comfy Cloud MCP connects to hosted infrastructure. Their setup, authentication, tools, and costs should not be treated as interchangeable.

Does using the same seed guarantee identical images?

No. A fixed seed helps control experiments, but model changes, workflow settings, software versions, and execution conditions can affect results. Record the full configuration, not just the seed, and verify outputs when moving between environments.

Does connecting Claude give ComfyUI more GPU memory?

No. MCP and Computer Use provide access, not additional compute. You still need suitable hardware for the workflow. Reducing memory demands or moving generation to a machine with more available VRAM may help.