Comfy MCP: Drive ComfyUI From Your AI Agent (2026)

One-sentence definition

Comfy MCP is the official Model Context Protocol server from the ComfyUI team that exposes the full ComfyUI engine over MCP — so an AI agent can search models, nodes, and templates, then build, run, save, and share generative workflows (image, video, audio, 3D) in natural language, with the actual rendering happening on Comfy Cloud GPUs.

In the team’s words: “Comfy MCP exposes the full ComfyUI engine over the Model Context Protocol — so your assistant can access the ecosystem, build workflows, and generate images, video, audio, or 3D.” The launch headline is blunter: “Turn your agent into a creative technologist.”

Why it exists

ComfyUI is the most powerful open generative-AI tool and the least approachable. You build by wiring a node graph — load checkpoint, CLIP-encode, sample, VAE-decode, save — and to use it well you download models, manage custom nodes, and usually own a GPU. That control is exactly why studios and power users love it, and exactly why most people bounce off it.

Comfy MCP removes the on-ramp. The launch post puts it plainly: “If you heard about ComfyUI but never tried it because it’s complicated, that’s not the case anymore” — “No nodes, no download, no GPU, no node graphs if you don’t want them.” The agent picks a template, fills in the inputs, runs it on Comfy Cloud, and hands you the output. The graph still exists underneath; you just don’t have to touch it.

This matters beyond convenience. ComfyUI grew into a tool with millions of users and tens of thousands of community-built nodes; a recent nine-figure-valuation raise is funding the cloud and ecosystem push. An official MCP is how that engine reaches the agents people already work in.

The named pieces

Four parts. Hold these and every tool name in the catalog explains itself.

The plumbing runs one direction: agent → MCP server (HTTPS) → Comfy Cloud (GPU execution). The thing to internalize early: this is cloud-only. The official server does not drive a ComfyUI you run on your own box — that’s what the community servers do. Here, the cloud is the runtime.

Install (every client)

Setup is OAuth against your Comfy account — create one at cloud.comfy.org or in the Comfy desktop app first. Then pick a path.

Claude Code — plugin route (easiest). The plugin also installs handy slash commands like /comfy-cloud:generate-image and /comfy-cloud:generate-video:

/plugin marketplace add Comfy-Org/comfy-skills
/plugin install comfy-cloud@comfy-skills
/mcp           # select comfy-cloud → Authenticate (OAuth)

Claude Code — direct connection (no plugin). One command wires the remote HTTP server:

claude mcp add --transport http comfy-cloud https://cloud.comfy.org/mcp

Claude Desktop. Open Customize → Connectors → + → Add custom connector, set the remote MCP server URL to https://cloud.comfy.org/mcp, click Add, and sign in when the OAuth prompt appears. Config locations for every client are on our Claude Desktop and Claude Code pages.

Headless / CI. Swap OAuth for an API key (create one at platform.comfy.org/profile/api-keys; keys start with comfyui-):

claude mcp add --transport http comfy-cloud https://cloud.comfy.org/mcp \
  -H "X-API-Key: comfyui-…"

The smallest end-to-end run

Once authenticated, the fastest proof is a single image. In Claude:

You: Using Comfy, generate a 16:9 product shot of a ceramic
     coffee mug on a wooden table, soft morning light.

Claude → search_templates({ query: "text to image", media: "image" })
Claude → submit_workflow({ workflow: <API-format graph>, inputs })
  ← { jobId: "job_abc123" }
Claude → get_job_status({ jobId: "job_abc123" })
  ← { status: "running" }  → … → { status: "completed" }
Claude → get_output({ jobId: "job_abc123" })

Claude: Here's your mug shot (1536×864). Want a few variations,
        or a version with steam rising from the cup?

That one request exercises the whole chain: discover a template, submit it to Comfy Cloud, poll, fetch the output. The agent does the node wiring; you describe the picture. To iterate, it chains outputs:

You: Take that image and upscale it 2x.

Claude → search_templates({ query: "upscale" })
Claude → use_previous_output({ jobId: "job_abc123" })
Claude → submit_workflow({ ... })   # upscale graph on the prior result

Claude: Upscaled to 3072×1728. Saved both to your Comfy Cloud
        account — want me to publish a share link?

use_previous_output is the quiet hero here: it passes one run’s result straight into the next without a download/re-upload round trip. That’s what makes multi-stage pipelines (generate → upscale → background-remove) feel like one conversation.

The 16 tools

The surface splits cleanly into four jobs: discover what’s available, execute workflows, manage saved ones, and share. Naming them tells you exactly what the agent can reach.

The discovery tools are what keep the agent honest. search_models, search_nodes, and search_templates ground it in what actually exists in the Comfy catalog instead of a hallucinated node name — the same reason grounded tools beat from-memory guesses everywhere else.

The execution cluster is an async job model: submit, poll, fetch. That’s deliberate — generative runs take seconds to minutes, so the agent fires submit_workflow, then get_job_status until it’s done. If you ever wonder why it “waits,” that’s the loop.

Sharing a workflow URL

This is the feature the launch leads with, and it’s the one that earns the “production pipelines” framing.

The payoff is reproducibility. The team frames shared generations as “100% reproducible, made for long-term projects, not one-off generations.” In practice: one person dials in a workflow, publishes the URL, and a teammate’s agent re-runs it on fresh inputs without ever opening a node editor. A workflow URL becomes a portable, agent-readable recipe — the closest thing generative AI has had to a shareable build script.

What I got wrong

Two assumptions cost me time. Both are easy to repeat.

I assumed it would drive my local ComfyUI. I have ComfyUI installed and expected the MCP to talk to it. It doesn’t — the official server is Comfy Cloud only. Execution happens on Comfy’s GPUs, not mine. If driving a local instance is what you want, that’s a community server (artokun’s or joenorton’s), and conflating the two will send you in circles.

I read “connect Codex, Cursor, or Hermes” as “works in Codex today.” It’s marketed that way, but first-party OAuth support at beta is Claude Code and Claude Desktop. The endpoint is a normal remote MCP server, so a determined Codex user can wire it up — but there’s no published, supported recipe yet. I burned twenty minutes expecting a one-liner that didn’t exist. Start in a Claude client; revisit the others later.

Real workflows where it earns its place

1 · Batch ad variations

“Generate 20 variations of this product shot in square, vertical, and 16:9.” The agent picks a template, submits the runs, polls them, and collects the outputs — the exact use case the launch highlights. You describe the brief; Comfy Cloud does the GPU work in parallel.

2 · A reusable pipeline, run by a teammate

Build a generate → upscale → background-remove chain once, save_workflow, share_workflow, and hand the URL to a colleague. Their agent calls import_shared_workflow and runs it on their images. Nobody re-learns the node graph; the recipe travels.

3 · Learning ComfyUI by watching it work

Ask “what nodes does this template use, and why?” The agent calls get_saved_workflow and search_nodes and walks you through the graph. It’s a gentler on-ramp to the real tool than staring at a blank canvas — you learn the vocabulary from a working example.

4 · Storyboard to clips

Feed a set of stills and ask for short cinematic clips. With upload_file for inputs and a video template via submit_workflow, the agent turns a storyboard into motion — another use case the team calls out, and a real test of the async job model since video runs are the slow ones.

Common mistakes

Honest limits — what it can’t (and shouldn’t) do

The part the demo reel skips.

• It’s cloud-only and account-bound. No local GPU path, no offline mode. Your inputs and outputs flow through Comfy Cloud. That’s the trade for zero setup.
• Pricing wasn’t published at launch. It’s open beta and free to connect, but runs consume Comfy Cloud GPU compute, a paid product. Budget for the executions, not the connection.
• Client support is narrower than the headline. Claude Code and Claude Desktop today; Codex, Cursor, and Hermes are positioned, not confirmed turnkey.
• It’s beta. Tools and behavior may change. Great for exploring, risky to build a production integration against without pinning expectations.
• It doesn’t replace taste. The agent runs the pipeline; the creative direction, the prompt craft, the “is this actually good” — still yours.

Who it’s for / who it isn’t

Community signal

Comfy MCP launched on June 29, 2026, so the strongest verified signal is the team’s own announcement, embedded above. Grassroots reaction on Reddit and HN was still thin a day in — rather than invent threads, here’s the most useful real context: this is ComfyUI formalizing a pattern the community already built.

Before the official launch, several community MCP servers already drove ComfyUI from an agent — most notably artokun/comfyui-mcp (local-first, explicitly positioned against a “cloud-exclusive” official server) and joenorton/comfyui-mcp-server (a lightweight local Python server). The official one’s differentiators are first-party support, OAuth, and Comfy Cloud GPUs — no local install. The two answer different needs.

The sharpest critical voice came on the launch post itself:

That critique echoes the broader 2026 “is MCP just overhead?” debate — the argument that wrapping an existing API in MCP adds tokens without adding capability. It’s a fair challenge. The counter: MCP buys you discovery, authorization, and a uniform agent interface the raw API doesn’t, and for non-developers “talk to Claude” beats “learn the prompt endpoint” every time. Both things are true.

The verdict

Frequently asked questions

Glossary

• ComfyUI — the modular, node-graph GUI and backend for diffusion models: image, video, audio, and 3D generative workflows.
• Comfy Cloud — Comfy’s hosted GPU runtime; where Comfy MCP executes workflows.
• Workflow — a ComfyUI node graph in API format; the unit you build, run, save, and share.
• Template — a pre-built workflow from comfy.org you can search and run as a starting point.
• Node — a single processing step in a workflow (load model, sample, decode, save).
• Share URL — a ?share=<id> link to a published workflow that any agent can import and re-run.
• MCP — Model Context Protocol; the standard that lets an AI client call external tools. See our explainer.
• HTTP transport — the agent talks to a remote MCP server over HTTPS, rather than running it as a local subprocess.
• OAuth — the sign-in flow that authorizes the connector against your Comfy account.

Sources & links

Primary

• Launch post: “Comfy MCP — Turn your agent into a creative technologist”
• Docs (tools, install, auth): docs.comfy.org/development/cloud/mcp-server
• Product page: comfy.org/mcp
• Launch announcement & demo video: @ComfyUI on X
• Source repo: github.com/comfyanonymous/ComfyUI (GPL-3.0)

Community / context

• artokun/comfyui-mcp — leading local-first community alternative
• joenorton/comfyui-mcp-server — lightweight local Python MCP server

Internal

• Claude ComfyUI workflow-builder skill guide
• Runway MCP — video generation from your agent
• Nano Banana vs DALL-E vs Midjourney vs Flux
• What is the Model Context Protocol?