ComfyUI Open-Sources Local MCP Server

Comfy MCP itself isn't new. Until now, the cloud connection at cloud.comfy.org/mcp came first. There's nothing to install, but generation runs on Comfy Cloud's hardware, and it requires a subscription.

What just opened is the flip side. The local connection runs as a process on your own machine, directly driving a ComfyUI installation you already have. It's like someone who used to rent a studio for every shoot finally installing lights in their own workshop. The gear is yours, and now the agent holds a key to the door too.

The two connections aren't mutually exclusive. The documentation notes that running both at once is a common setup — offloading heavy jobs to the cloud while running familiar custom nodes locally.

Measuring the Doorway Before Bringing In a Model

In the local connection, the agent does three main things. First, it checks the hardware. Before downloading a model, it determines whether your GPU specs can actually run it.

It's like measuring your front doorway before buying a refrigerator. This heads off one of the most common wastes in local generation: downloading the full weights only to discover afterward that memory falls short.

Second, it handles setup on your behalf. Fetching model files, launching instances, and initializing workflows all happen within the conversation. Third, it reads your installation state. The agent sees every installed node, including custom nodes, along with the list of models on disk.

The third point matters most. Workflows built by others often break in your environment because they call nodes you don't have — but if the agent knows your node inventory, it builds graphs using only what's actually available.

Comfy Org has also kept the custom node ecosystem open. Agents can install and use node packs, including specialized tools like depth-based restyling, according to the documentation. It's the difference between working with someone who already knows what's in your toolbox and someone who has to buy new tools every time.

From a Single Prompt to MiniMax H3

The blog post cites MiniMax H3 as an example of running an open-weight video model locally. When a user says "let me run this locally," the agent checks GPU compatibility, downloads the weights, finds a template, validates it against installed nodes, and delivers the result to a local output folder.

Setup follows the same pattern. Comfy Org instructs users to simply paste the installation documentation URL into the agent — say something like "set up the local Comfy MCP connection, here's the guide" and the agent reads it and follows along. Manual installation steps also remain documented.

Requirements are straightforward: Python 3.10+, comfy-cli (1.14.0+) available on PATH, a ComfyUI workspace, and — to actually run generations — a ComfyUI instance launched via comfy launch.

What's Free and What Costs Money

The tools exposed by MCP split broadly into discovery and execution. Discovery includes template search (search_templates), model search (search_models), node search (search_nodes), node input spec lookup (get_node), and graph structure queries (cql). Execution includes template execution (run_template), custom API workflow submission (submit_workflow), batch submission (submit_batch), plus job status checks and cancellation.

This is where cost diverges. Discovery is free on both connections — a Comfy account is all that's needed. Running generation on the cloud requires a subscription (new users get 5 free trials), while local generation is free unless it calls a partner model for inference. Partner APIs like Flux, Grok, Gemini, OpenAI, and Ideogram are invoked via partner_generate, and their inference costs apply even locally.

Authentication varies by client. Claude Desktop, Claude Code, Codex, and OpenCode use OAuth with a one-time browser approval, while Cursor doesn't support OAuth and requires an API key. Keys are generated at platform.comfy.org and passed via the X-API-Key header or an environment variable.

Things to Know Before Connecting

The documentation itself flags several limitations. Output generated via submit_workflow may not have workflow metadata embedded. Given how common it is for ComfyUI users to extract workflows back out of images, this is not a minor restriction.

Retrieving output requires running a returned download command in your shell, and upload size limits vary by MCP client. Complex workflows with many interconnected nodes may not come out right on the first try and could require refinement or retries.

For Mac users, the documentation is blunt: today's open-weight models are large, and Apple GPUs won't deliver usable speed, so use the cloud connection instead. If you were planning to fire up the local connection first on a MacBook, it's better to switch that order around.

Editor's View

Having used ComfyUI for a long time, what always bothered me wasn't performance but the nature of the barrier to entry. It wasn't that it was hard, exactly — it was that you couldn't tell where your environment's problems ended and the workflow's problems began. When a node turned red, someone had to figure out, one by one, whether it was a missing model, a missing custom node, or a version mismatch.

What caught my attention in this announcement wasn't the video-generation demo but a single line: "validates it against installed nodes." Most automation tools built around ComfyUI so far have focused on generating workflows. But the real time sink was never the generation step — it was fitting someone else's workflow into your own environment. An agent that reads your disk and your node list signals that the center of gravity in automation has shifted from generation to environment alignment.

Opening up the local connection isn't just generosity either. Cloud MCP requires a subscription to run generation, and that threshold surely turned away no small number of people. Making local generation free suggests Comfy Org has shifted its monetization point away from generation itself and toward partner models and cloud convenience. Underlying this is the calculation that it's hard to charge twice someone who's already bought the GPU.

For teams in Korea, this carries two practical implications. First, if there's a studio somewhere with idle GPUs, there's now a standard path to hand that hardware over to an agent. Until now, each team hit the ComfyUI API with its own scripts — scripts that vanished the moment whoever wrote them left.

Second, for teams handling material that can't leave the premises, the local connection isn't an option — it's the only path. The condition that source material never leaves your own disk is frequently written into contracts in advertising, gaming, and broadcasting.

MCP is becoming more than a spec for calling models — it's turning into a key that opens the working environment itself. ComfyUI has released that key as open source, handing its entire graph — among the most complex of creative tools — over to agents. Blender and DaVinci Resolve are likely next: Comfy Org named exactly those tools as examples of upcoming desktop integrations.