ComfyUI with Claude and Codex · The Official MCP Simplifies Workflows

Quick Summary

• Credit: Embedded video and original test belong to Tim Simmons of Theoretically Media channel. The page uses user-supplied transcription and cross-references demos with official ComfyUI and Model Context Protocol documentation.
• Comfy MCP connects an agent to the ComfyUI installation. The agent can check the server, search for templates, nodes and models, validate a workflow, execute it and collect the results.
• The official local link is open source and works with the hardware, models and custom nodes that already exist on the machine. ComfyUI needs to be running for runtime tools.
• MCP is in public beta. An agent can build useful graphs, but complex workflows may require corrections, validation and a second attempt.
• Local does not mean zero cost. There is no longer a charge per generation from the supplier, but the GPU, storage, electricity, rendering time and environment maintenance remain.
• Partner Nodes and Comfy Cloud Nodes are not running on-premises. They consume credits, send the necessary data for remote processing and follow specific retention and billing conditions.
• The most efficient workflow is hybrid: the agent does discovery, installation, connection and debugging; the person changes prompt, duration, resolution, seed and other simple fields directly in the graph.
• Templates are the best starting point. The official documentation indicates that ComfyUI checks for dependencies and missing models when loading a template.
• Official installation requires Python 3.10 or higher, comfy-cli 1.14 or higher, a ComfyUI workspace, and the comfy-mcp package. Documentation must be the source of truth because the process can still change.
• Compatible hardware depends on the model. ComfyUI supports multiple platforms, but open-weight video models can require a lot of VRAM, RAM, disk space, and generation time.
• Installing a LoRA via natural language is convenient, not automatic in terms of trust. Check source, license, format, destination, compatibility and hash before using the file.
• The real change is one of interface: the node graph continues to be the reproducible engine, while the conversation starts to function as an intention, diagnosis and operation layer.

Credit, method and state of the evidence

The embedded video was published on August 20, 2026 by Theoretically Media. Tim Simmons leads the test and describes himself as a basic ComfyUI user, a useful position for evaluating whether MCP actually reduces input friction.

The demo is a creator test, not a benchmark. The video shows a PC equipped with a top GPU, concrete workflows and a selection of outputs. The observed generation time, around 204 seconds in one example, should not be extrapolated to other GPUs, models or definitions.

The capabilities, requirements, and limits on this page have been verified in the official ComfyUI documentation, the first-party Comfy-Org/comfy-mcp repository, and the MCP specification. Prices and model catalogs may change, so the article avoids transforming momentary values ​​into universal rules.

Short answer: Did MCP make ComfyUI easy?

It made it more accessible, especially in the part that requires knowing nodes, connections, dependencies, paths and compatibility. A person can describe the objective and ask the agent to discover a template, assemble the workflow, install what is missing, validate and execute.

It did not remove the need for direction. The agent does not automatically know which reference defines identity, which movement must be preserved, which compromise between speed and quality is acceptable or whether the output meets the brief.

The more precise formulation is this: MCP reduces the distance between intention and executable graph. ComfyUI remains the production system, and the person remains responsible for permissions, cost, data, evaluation, and the end result.

1. What is MCP, without confusing protocol with model

MCP stands for Model Context Protocol. It is an open protocol for connecting an application with LLM to servers that expose context and tools. In the case of ComfyUI, these tools allow the agent to interrogate and operate the generation system.

The MCP does not generate images itself. It also does not replace MiniMax H3, LTX, Flux, Seedance or any other model. It provides an operational language between the client, such as Claude Code or Codex, and the engine that knows nodes, models and workflows.

The MCP specification recommends human in the loop, visibility into tools, and the ability to deny invocations. This is especially important when a tool installs code, moves files, runs an expensive render, or sends media to a remote provider.

2. What your local Comfy MCP can see and do

According to the official documentation, the local connection inspects the ComfyUI that is actually installed. You can see core nodes and custom nodes, models on disk, compatible templates and server information.

The main tools cover server verification, template search, node and model search, workflow validation, execution, job tracking and output collection. They can also start or stop the local instance when that action is available and authorized.

This insight solves a common problem with generic tutorials: a graph may seem correct in theory and fail because the installation has other node names, different versions, or models in another folder. The agent can compare the plan with the real environment before spending several minutes on a render.

3. Local, Comfy Cloud and Partner Nodes are not the same thing

Local: the workflow runs on your machine and uses the models, custom nodes and capacity of your GPU. There is no charge per call for the local model, but there are equipment, energy, storage and time costs.

Comfy Cloud: the workflow runs on GPUs managed by ComfyUI. It is useful when local hardware is not enough or when you want greater speed without maintaining the infrastructure. The cloud connection and access conditions are different from the local connection.

Comfy Cloud Nodes: Specific nodes send a step to ComfyUI GPUs and charge per GPU-second in credits. The documentation distinguishes these nodes, which run hosted open source models, from Partner Nodes.

Partner Nodes: call external suppliers and models. They require credits, may apply moderation from the third party and send the necessary inputs for processing. The documentation indicates automatic retention of inputs and outputs from Partner Nodes for 24 hours, so important results must be downloaded in time.

4. Requirements and installation: short in conversation, concrete in the system

The video summarizes the process as a sentence addressed to the agent. The official documentation gives technical content to this sentence: Python 3.10 or higher, comfy-cli 1.14 or higher in the PATH, a valid ComfyUI workspace and the comfy-mcp package.

The MCP server does not implicitly launch ComfyUI in all situations. To run, ComfyUI needs to be active, for example via comfy launch, or the agent must invoke the launch tool with authorization.

The safest way to start is to give the agent the address on the official documentation and ask for a plan before installing. The plan should show commands, installation location, PATH changes, chosen workspace, and how to undo the configuration without removing models or personal outputs.

5. The first workflow should prove connection, not ambition

Start with a simple generation from an official template. The template library contains natively supported graphs and examples of custom nodes. When uploading a template, ComfyUI checks for missing templates and can guide the download.

The first test must answer five questions: the agent finds the installation, the server is accessible, the template opens, the dependencies are recognized and the output arrives in the expected folder.

Only after this smoke test does it make sense to ask for a pipeline with several steps. If you start with image, video, upscale, interpolation and delivery in the same run, an error at the end makes it difficult to figure out which connection or dependency caused the failure.

6. Image-to-video testing shows where the agent helps most

In the video, Claude builds a workflow that first generates an image and sends it to an image-to-video model. Tim doesn't need to manually draw all the connections. Executes the graph and receives a local clip.

The value is not in the cyberpunk example itself. It's in the reproducible composition: an output becomes the input of the next step, the parameters are visible and the workflow can be saved, duplicated or converted into a small internal product.

To improve this test, set the objective before the graph: reference, movement, duration, fps, aspect ratio, resolution, available VRAM, output folder and approval criteria. Without this contract, the agent can construct something technically valid but creatively irrelevant.

7. What to delegate to the agent and what to edit by hand

Delegate discovery, compatibility, initial framework, wiring, error reading, guided installation, and validation. These are tasks in which the agent can quickly compare documentation, environment and requirements.

Directly edit prompt, seed, duration, number of frames, aspect ratio and other obvious fields after understanding the graph. Asking the agent for a new call for each simple change increases token consumption, latency and the risk of touching another part unnecessarily.

The best interface is progressive. At the beginning, ask for explanations about sampler, scheduler, steps and dimensions. Over time, transform recurring changes into a checklist or subgraph with clear inputs. The goal is not to depend forever on the agent, but to use the agent to learn the system it is operating.

8. Local is no fee per generation, not no cost

Creator test describes local generation as free because there was no API charge. For professional planning, the bill should include amortization of GPU, power, SSD, model downloads, maintenance, wait time, and review work.

The useful metric is cost per approved second. Record GPU time, number of attempts, output duration, estimated energy, human minutes and any paid steps. A local clip rejected five times can cost more than a remote call approved on the first try.

Local tends to win when there is recurring volume, sensitive data, models that fit comfortably on the hardware and tolerance for queues. Cloud tends to win in peaks, short deadlines, very large models and teams without time to maintain the environment.

9. Hardware: Application may open, model may not fit

ComfyUI supports Windows, Linux and macOS, with paths for NVIDIA, AMD, Intel, Apple Silicon and even CPU. Application compatibility does not guarantee a viable experience for each model.

The video uses an RTX 5090, a high-end case that reduces the validity of any universal conclusions about speed. To choose a model, check required VRAM, accuracy, resolution, number of frames, offload, system RAM, temporary space and size of weights.

MCP's own documentation recommends cloud for Mac users who want to run very large open-weight video models locally, because current performance may not be practical. Before downloading tens of gigabytes, ask the agent for a fit estimate and a smaller alternative.

10. API nodes transform ComfyUI into a hybrid orchestrator

The remote catalog allows local stages and commercial models to be placed in the same graph. A pipeline can create a local image, animate it with another model, apply a remote transformation, and finish it back on the computer.

Convenience hides an operational frontier. When the flow crosses a Partner Node, it is no longer entirely local. There are credit consumption, data transfer, vendor policies, competition limits, and a retention window.

Visually mark each zone of the graph with three labels: local, Comfy Cloud and partner API. Ask the agent to estimate which nodes can spend money and require confirmation before executing. The first-party repository includes spending consent mechanisms, but the person must continue to review the call and the chosen model.

11. Install LoRAs and custom nodes with natural language

The video shows the most seductive promise: pasting the URL of a LoRA and asking the agent to install it. This reduces searching for folders, names and links, especially for those just starting out.

A LoRA is not just an interesting file. Confirm base model, license, recommended resolution, trigger words, suggested strength, format and provenance. For custom nodes, add repository revision, dependencies, recent commits, open issues and code that will be executed locally.

Request a dry run: the agent must explain what they are going to download, where, how much space it takes up and which files will be changed. Then install one component at a time, restart when necessary and validate with a minimal workflow.

12. Security: trust does not replace limits

The humorous tone of the video tests destructive requests and observes the agent's refusals. This demonstrates guardrails in an interaction, not a guarantee for all models, tools, permissions, or versions.

The professional principle is least privilege. Give access only to the necessary workspace, maintain backups, do not authorize recursive deletions by default, review installation commands and separate sensitive projects from experiments.

API keys must live in environment variables or secret mechanisms, never within the prompt or a file that can be published. For paid calls, maintain per-run consent until you know the cost and workflow behavior well.

13. A workflow is only reusable when the environment is registered

Saving just the JSON is not enough. Register ComfyUI version, custom nodes, commits, models, hashes, LoRAs, samplers, schedulers, seeds, resolution, frames, fps and expected paths.

Group nodes by function and expose the inputs that the team actually changes. A readable graph reduces the need to talk to the agent at each execution and facilitates auditing when an update changes the result.

After approving a pipeline, create a small test with asset and reference result. Run it after updates. If it fails, compare environment and dependencies before rewriting prompts or assuming the model has gotten worse.

14. Practical playbook for MCP-assisted production

Phase 1, diagnosis: inventory hardware, storage, installation, nodes, models and limits. Phase 2, proof: run a simple template and confirm output. Phase 3, composition: build one step at a time and validate connections before full rendering.

Phase 4, execution decision: classify each node as local, cloud or partner. Estimate cost, data sent, and time. Phase 5, control: ask for confirmation for installations and expenditure, save versions and download remote outputs.

Phase 6, review: assess visual quality, continuity, artefacts, rights and alignment with the brief. Phase 7, product: Convert the approved graph into a template, subgraph, or simple interface so that others can use only the necessary controls.

15. Verdict: the node graph is no longer the gateway

The official MCP doesn't kill the hard part of AI generation. It removes much of the mechanical setup that forced new users to think like engineers before testing an idea.

ComfyUI becomes more interesting as a visual and reproducible backend. The person describes intent, the agent translates and diagnoses, and the graph maintains explicit operations. This division is more powerful than hiding the interface completely.

The recommendation is to experiment with a small and local workflow. If the system proves value, move to hybrid pipelines with defined spending, data, and permissions limits. The best outcome is not to never touch a node again. It's knowing when conversation helps and when a direct adjustment is faster, cheaper and safer.