Today, we are introducing Comfy MCP in public beta: Connect your existing workflows with the power of the Comfy Ecosystem across Claude, Codex, Hermes, Cursor, and all the other agents. This is the first MCP built for production pipelines.

Turn your Claude into a creative artist.

The MCP provides your agent with access to all the latest image, video, 3D, and audio models, as well as hundreds of popular ComfyUI workflows. We auto-update the best-practice workflows, so your agent always knows what is up to date.

Want to try 20 product-placement images for your brand ads? Character design for your game art? Script-to-shot ideation at scale? Do it with your agent today!

Today, everyone gets their ComfyUI expert.

If you heard about ComfyUI but never tried it because it’s complicated, that’s not the case anymore. Today, your agent learns all these for you:

• Build, edit, and run workflows

• Search models, nodes, and template workflows

• Save and re-run workflows

• Read and execute shared workflow URLs

• Retrieve the workflows of all MCP generations in the app

Everything is now in natural language. No nodes, no download, no GPU, no node graphs if you don’t want them.

Built for reproducibility and teamwork

Share a workflow URL with anyone, including the agents.

If your team members don’t want to learn the workflow you built, now their agents can run it too.

Edit the same pipeline with your agent. Every generation is 100% reproducible, made for long-term projects, not one-off generations.

Example use cases for production work

• “Take one hero sneaker shot and generate 20 ad variants in 4 aspect ratios for Meta Advantage+.”

• “Read my saved product-shot workflow and re-run it on these 5 new images.”

• “Turn three storyboard frames into a cinematic clip — then explain the workflow so my teammate can reuse it.”

• “Generate a consistent character across 12 card-art poses.”

Get started in 5 minutes

Comfy MCP connects your Comfy account to your agents, so you need a Comfy account to get started.

1. Create a Comfy account at cloud.comfy.org or in the desktop app.

2. For Claude Desktop, please add a Custom Connector as shown below.

3. For other agent clients, please send the docs to your agent:

   “Agent, please help me install Comfy MCP: https://docs.comfy.org/agent-tools/cloud”

More resources: CLI and Skills

For more information about the MCP, please refer to our documentation on installation, the list of tools, and multiple auth methods: https://docs.comfy.org/agent-tools/cloud

To expand your agentic experience, we are also enabling Comfy CLI in Beta. You can also find more details in the docs.

We are also starting a Comfy Skill repository for our creative technologist team and community members to share their Comfy skills. You are always welcome to contribute and comment! https://github.com/Comfy-Org/comfy-skills/

Feedback

The MCP is still in beta. Please try it out, stress test it, and tell us what works and what doesn't. We are genuinely grateful for all kinds of feedback.

• Feedback Survey: https://links.comfy.org/cloudmcpbeta

• Discord channel: Join the #comfy-mcp-and-cli channel in our Discord https://discord.gg/xWJn6nhE3R

As always, enjoy creating!

Seedance 2.0 Mini runs as a selectable model on the existing ByteDance Seedance 2.0 video nodes — Text to Video, First-Last-Frame to Video, and Reference-to-Video — and ships with dedicated templates.

Seedance 2.0 Mini Reference-to-Video

Seedance 2.0 Mini Text-to-Video

Where Mini fits

Mini gives you the Seedance 2.0 cinematic toolkit at a lower cost per run. It runs on the same Seedance 2.0 video nodes and takes the same prompts. The one tradeoff is resolution: Mini outputs 480p and 720p, while native 1080p and 4K stay on full Seedance 2.0 and 2.0 Fast. For drafting, iterating, and generating at volume, Mini gets you the same look for less.

What Mini does

Mini reads a prompt as a full visual narrative rather than a single isolated clip, generating structured multi-shot sequences with coherent pacing across shots. Character identity stays stable across those shots, so a character remains visually aligned through an entire sequence — perfect for storytelling and branded content. It maps natural language directly to scene composition and visual style, producing multi-scene output from plain text.

Native 4K output

Native 4K is a full Seedance 2.0 feature — not Mini, which tops out at 720p. Full Seedance 2.0 generates native 4K with 10-bit color. Fine detail resolves cleanly at 4K — hair strands, fabric textures, architectural lines, and material surfaces — and holds through complex motion, not just on static frames. The 10-bit color is native rather than upconverted or wrapped at export, which means real grading headroom, smoother gradients, and cleaner output to work from downstream. This is the tier to finish on when a shot needs to ship at high resolution.

Getting Started with Mini

1. Update ComfyUI to the latest version, or open Comfy Cloud.

2. Load a Seedance 2.0 Mini template from the Templates panel, or add a ByteDance Seedance 2.0 node and select Seedance 2.0 Mini as the model.

3. Set resolution to 480p or 720p, drop in your prompt and run.

HappyHorse 1.1 is now available in ComfyUI as a Partner Node. This video model is engineered for real-world production use cases, including short episodic series, e-commerce commercials, brand marketing content, and game cutscenes.
A standout feature of the model is native synchronized audio generation. It produces dialogue, sound effects, and background music in one single render pass without extra steps.
Version 1.1 targets five core production-critical capabilities: dynamic, expressive motion; consistent character rendering; reliable prompt adherence; stable text rendering; and authentic cinematic framing.

Download Workflow

What’s new in 1.1

• Dynamic expressiveness: Smoother motion and frame consistency eliminate the stiff, sluggish movement from v1.0.

• Enhanced multi-image reference-to-video (R2V): Faithfully preserves input details, supporting up to 9 reference images per generation.

• Multi-character consistency: Multiple character references keep a distinct look with no visual cross-contamination.

• Flexible character × scene combinations: Feed characters and scenes as separate references. Characters stay fully consistent even as the background environment changes.

• Upgraded instruction following: Better long-context retention handles prompts beyond 2,500 characters, and a single prompt can describe 6–8 consecutive scenes with the model autonomously allocating time and switching camera angles.

• Natural skin and close-up viability: Fixes shiny skin and over-sharpening issues, with lifelike texture for series and commercials.

• Cinematic language: Full support for terms like shot-reverse-shot and tracking shot, with far more cohesive transitions and pacing between shots.

• Upgraded audio: More accurate dialogue and sound-effect rendering, with emotional performance layered on top of tight audio-video synchronization.

Three nodes, one model

HappyHorse 1.1 ships as three nodes, each tuned to a different job:

• Text-to-Video (T2V): Build a complete scene from scratch. You control style, shot size, lighting, action, and audio entirely through the prompt.

• Image-to-Video (I2V): Animate a static first frame. The image already carries the look, so you just describe the motion and the camera move.

• Reference-to-Video (R2V): Orchestrate a multi-character stage play. Map characters and scenes to reference images, then direct them through a timestamped storyboard with per-character dialogue.

All three models support 720p and 1080p output, video lengths ranging from 3 to 15 seconds, plus flexible aspect ratios including 16:9, 9:16, 1:1, 4:3, 3:4, 21:9, and more. Every exported video comes with perfectly synced audio.

Getting Started

1. Update ComfyUI to the latest version

2. Find the HappyHorse nodes via the Node Library (search “HappyHorse”) or load a ready-made template from the Templates Library.

3. Pick your mode: Text-to-Video, Image-to-Video, or Reference-to-Video, wire in your prompt and any reference images, then run. Output arrives with audio baked in at 720p or 1080p.

Download Workflow (I2V)

Download Workflow (T2V)

Download Workflow (R2V)

Krea 2 OSS runs locally in ComfyUI today. Both open-weight checkpoints — Krea 2 RAW and Krea 2 Turbo — load through the standard diffusion model nodes, so you can train and generate locally on your own hardware. Krea 2 OSS excels at generating diverse aesthetic outputs and is definitely an image model we recommend to add to your stack. For information directly from Krea on the new checkpoints, check out the github repository and read the technical report.

Download Krea 2 Turbo Workflow

Two models, designed to work together

Krea 2 OSS ships as two checkpoints with distinct jobs.

Krea 2 RAW is the base model: a pretrained checkpoint with no distillation and no post-training. It produces diverse, malleable outputs and is the checkpoint to use for fine-tuning, post-training research, and LoRA training. RAW is not tuned for final-quality generation on its own.

Krea 2 Turbo is an 8-step distilled checkpoint built for fast, high-quality text-to-image. It’s distilled from a fully post-trained RL checkpoint, so it produces higher quality than RAW but with lower variation between outputs.

The two are meant to be paired. Train a LoRA on RAW, then apply it on Turbo. LoRAs trained on RAW express strongly on Turbo, which lets you train on the malleable base and run fast inference on the distilled model.

Model Highlights

Speed. Turbo generates in 8 steps. Generation is quick and allows for fast iteration.

Stylistic range. Krea 2 OSS covers a wide aesthetic and stylistic range, from photographic portraits to anime to high-contrast editorial macro work.

Malleability. RAW is undistilled, which makes it well suited to fine-tuning and research. Diverse output and a tunable base give you room to push the model toward specific styles or subjects.

Prompting

The model was trained on short, medium, and long natural-language prompts. Detailed, long prompts give the best quality. Our templates ship with a Prompt Enhancer system instruction directly from the Krea team.

Architecture

Krea 2 OSS is a 12B dense DiT. It uses the Qwen Image VAE and a Qwen3-VL text encoder with multi-layer feature aggregation.

Get started

1. Update ComfyUI to the latest version 0.26.0.

2. Download the workflow below, or find it in the template library

3. Follow the note in the workflow to download models and save them in the correct model directory

Tell us about The Song of Drifters. What is it about, and where did it start?

The Song of Drifters is a documentary animation about people caught between leaving and returning, wanderers who drift through unfamiliar cities, holding onto memories of a homeland out of reach and searching for a sense of belonging. The title is a direct translation from an ancient Chinese poem about a mother’s love for a child who leaves her hometown. My version takes the opposite point of view, from the child’s perspective.

I built the film in ComfyUI. When I started, I was not trying to show what AI could do. I was trying to prove something almost opposite.

You came to this from illustration, not engineering. How did you end up in ComfyUI?

I started as an illustrator. I earned my BFA in illustration at the Rhode Island School of Design, then worked as a game concept artist, where I picked up shaders, Unity, and Unreal. That technical side made me a fast learner with new tools. Later I went to USC’s School of Cinematic Arts for an MFA in Expanded Animation, where I studied with Professor Kathy Smith.

By my thesis year I had moved from Stable Diffusion’s standard interfaces to ComfyUI, because I think in node-based structures and I wanted to control every step. Most AI tools are one click: you prompt, you click, you get a result. That is not what I wanted.

Walk us through the pipeline. What were you actually feeding the model?

_{Xindi’s ComfyUI workflow for the balloon sequence. Source: xindizhangart.com.}

My core technique was style transfer in Stable Diffusion 1.5, driven by IP-Adapter and ControlNet. What mattered most was what I fed it: my own work. The base materials were live-action footage I shot on an iPhone 15 Pro and 3D animation I built in Blender. The AI restyled imagery I had already made. It did not invent it.

_{Style-guide still from The Song of Drifters. Source: xindizhangart.com.}

Download Xindi’s style transfer workflow (json) on ComfyUI

I also trained custom LoRAs on my own video, footage of the cities I had lived in. Capturing that footage became a vital part of the documentary process. Wandering through the streets where I once lived let me reconnect with those cities. Most of it never appears in the final cut, but it lives in the visuals as training data. The hybrid pipeline made rendering the final look more efficient and saved more time for ideation.

For the dream sequences I combined animated 3D with AI morphing, moving from abstract to concrete to mimic the feeling of being half awake.

_{BTS clip, AI morphing. Source: Xindi Zhang}

Download Xindi’s AI morphing workflow (json) on Github

The film won gold at the Student Academy Awards and was shortlisted for the Oscars. What’s next?

I made the film for creative reasons, not career ones. I honestly did not expect it to connect to a job at all. Then it won the Golden Award at the 2025 Student Academy Awards and was shortlisted for the Oscars, and the calls started.

_{Xindi Zhang at the 2025 Student Academy Awards. Source: Oscars Press Office}

What people wanted was the combination: someone who understands both traditional craft and AI tools. I now work as an AI Creative at Amazon AI Studio building custom production pipelines. I see that same demand across the industry, with ComfyUI experience starting to show up as a requirement in job postings at major studios and design agencies.

It’s not the tool that steals my art. It’s the tool that expands my art.

My advice to other students is not really about software. AI is just another tool to convey ideas, but nothing is more important than the story itself. If you use AI, use it on purpose. The more you understand it, the more freedom you have to make work that is genuinely yours.

Xindi Zhang is a Chinese animation director and visual artist (RISD BFA in illustration, 2020; USC MFA in Expanded Animation, 2025). The Song of Drifters won the Golden Award at the 2025 Student Academy Awards and was shortlisted for the 98th Academy Awards. She works as an AI Creative at Amazon AI Studio, has collaborated with Sony Music's immersive studio, and is now on the faculty at the University of South Florida.

The Comfy Education Initiative is coming soon! Register your interest here to get early access to educational discounts, education exclusive slack / discord communities, and be notified as soon as the program is released.

This is a Comfy Vibe — vibe-coded, lightly tested apps we ship to show, not just tell, what you can build on Comfy. They're not hardened products, and we're not building them to gather data or prove a point — just things we wanted to exist, shipped fast and thrown into the world, rough edges and all. The whole point isn't any one app — it's the invitation. Pick an idea, vibe-code it on Comfy, and put it in the world. Here's one of ours.

Open Comfy Go on your phone. Type a prompt. Pick a model from the list. Tap generate; the job queues, runs, and an image — give it a moment, a video — comes back into the same gallery, on the phone. No laptop open somewhere. No browser tab. No node graph to wire up. The thing on your phone is a native app, and the picture came back from the same Comfy Cloud that runs the web product.

That's the whole pitch, and I want you to feel it before I explain anything: generating on Comfy Cloud now fits in your pocket — camera roll in, Photos out, the model picker a list you tap instead of a string you paste.

Comfy Go is a native SwiftUI app — Comfy Cloud's mobile edition. It's not the full node-graph editor; it's four curated generation flows — the ones you'd reach for from a phone. It shipped to TestFlight on June 12. There are two reasons I'm writing this up, and they're the same idea pointed in two directions: how accessible this is to use, and how accessible the API underneath is to build on. Both turn out to be true, and the second is why the first exists at all.

What's at your fingertips

Four generation flows — the full image/video by text/image matrix:

• Text to image — type a prompt, pick from any of the 18 models, get a picture.

• Image to image — bring a photo from your camera roll, restyle or edit it against the same catalog.

• Text to video — a prompt becomes a clip, no keyframes to hand-place.

• Image to video — hand it a still from your Photos and it starts moving.

Across those flows you pick from 18 models, the same catalog the web product draws on. You sign in with Sign in with Comfy — one tap, your own account, and you're in. Results save straight to your Photos, and everything you've made lives in an in-app gallery you can scroll back through. It's phone-native end to end: the camera roll is the input, the camera roll is the output, and the model menu is a list you tap, not a string you copy.

That's the user-facing half. Here's the half that makes it interesting to anyone who builds things.

The spine: it's all the public API

Comfy Go does not have a private back door into Comfy Cloud. It rides the public Comfy Cloud API — the same one anyone can call. There is no internal endpoint, no special-cased mobile shortcut, no privileged handshake. Everything the app does, you can do.

And "everything the app does" is smaller than it looks, because the client SDK underneath — a thin Swift layer called ComfySwiftSDK — comes down to two methods and one event you care about:

1. Submit a workflow.

2. Stream the job's events as it runs (queued, running, progress, done).

3. The stream hands you the outputs when it completes — the finished images or clip arrive as the last event, not a separate call you have to make.

Submit, stream, and the stream gives you the result. That's the contract. The SwiftUI layer on top never learned what an HTTP status code is; it knows "this job is queued," "this one is 40% through," "this one produced two images." Every screen in the app — all four flows, the gallery, the live progress bars — is built out of that one small surface applied in different shapes.

In Swift, that's the whole client — two calls and a switch:

Grab the copy-pasteable version from the SDK's Quick Start.

Add it to your Package.swift:

.package(url: "https://github.com/Comfy-Org/ComfySwiftSDK.git", from: "0.1.0")

It's 0.1.0, Apache-2.0, and dependency-free — Foundation and CryptoKit only, iOS 17+ / macOS 14+.

Here's the part that makes "accessible to build on" a fact and not a slogan: one person built this whole app, solo, in roughly a week. The repo opened April 6 with the BMAD plan; the first Swift scaffold landed the next day, and I shared it with the team within the week. The work was driven agentically through Claude Code on that plan — 8 epics, 57 stories — with one human steering. The output was around 17,200 lines of app plus SDK code: a native iOS app, four working pipelines, a model picker, a gallery, real sign-in.

The reason that's reachable, and not heroic, is the size of the surface you have to learn. If the API were forty endpoints with subtle ordering rules, a solo week-long native app would be a tall story. It's submit, stream, done. So the credible claim is just arithmetic: if a solo developer can ship a real native app on this API in about a week, your idea — the bot, the plugin, the side project — is reachable on the same surface.

The hard part of building on Comfy Cloud isn't the API. It's deciding what to make.

Try it / what's open

The beta. Comfy Go is an open TestFlight beta. It's a real app you can sign in to and generate from. If you want in, that's the whole step: join the beta on TestFlight.

The API. This is the part that needs no waiting list. The Comfy Cloud API that Comfy Go is built on is public — submit, monitor, retrieve. The full OpenAPI spec is the source of truth if the docs ever lag. The "submit, stream, and the stream gives you the result" shape is exactly as small in practice as it is on the slide. If a native iOS app fits in that surface, your thing probably does too. Go build.

The repo. The SDK is open source — ComfySwiftSDK on GitHub. That submit-and-stream boundary is the part most worth handing to other people, so it's what we opened up first: if you want to build on Comfy Cloud from Swift, start there. The app is following. Star it, file issues, send PRs — it's pre-1.0, so feedback on the API surface genuinely steers where it goes.

The numbers

• Generation surface — 18 models across 4 flows

• SDK surface — submit, stream the events, and the stream hands back the outputs

• Built by — one person, solo

• Timeline — ~1 week of build (first Swift scaffold Apr 7; shared with the team within the week)

• App + SDK code — ~17,200 lines

• How it was built — agentically, via Claude Code + BMAD — 8 epics, 57 stories

• The API — public Comfy Cloud API — the same one the web client uses

Related reading

• Comfy Internals: How we got four rival AI labs to fight over our code reviews

• From Workflow to App: introducing App Mode, App Builder, and ComfyHub

Comfy Go is a drop from Comfy Vibes — the banner on things we build for ourselves that earn a spot in the world.

What would you build on a three-call API? Drop it in the comments — I read every one.

If your idea of fun is taking a generative API with a three-call surface and seeing how good a product you can build on it before lunch — we're hiring.

At Comfy, I review a lot of code, and most of it isn’t written by people anymore. An agent drafts it, I shape it, and the volume I’m responsible for keeps climbing while the amount I personally type drops. One tired human can’t keep a hostile eye on that much code. So I stopped trying and built something that could.

The system: fan a PR diff out to four models from four different labs, two passes each, then let one judge consolidate the results. It runs in CI for a flat $200/month. The bet it rests on is counterintuitive: four models from the same lab aren’t four opinions, they’re one opinion in four voices. The fix for a tired reviewer was never a better model. It was more labs.

I open-sourced it for the team and for the public (repo at the bottom). Here’s how it works and what it cost.

The problem

Adversarial review is the part of my job I trust least to my own attention span. On PR number three of the afternoon I’m not as mean to the code as I was on PR number one, and the bugs don’t care what time it is. The masked errors, the silent type coercions, the off-by-one that only bites at scale: those need a fresh, hostile reader, and by 4pm I’m a tired, friendly one.

The ritual was already mechanical. Paste the diff into one model, ask it to attack the change. Paste it into another, ask for edge cases. Reconcile the lists, then start my own review. That’s a script waiting to happen. The reason I hadn’t written it: one model doing this is mediocre. It grades the code against the same priors it would have used to write the code, so it just tells me what I already half-believed.

To be precise about what “my code” means here: this reviews the cloud platform that runs ComfyUI, not ComfyUI’s rendering engine. In practice that’s our Go backend (the ingest and inference services, the OAuth implementation, the asset pipeline), the MCP server, our CI and infrastructure-as-code, and the workflow-API-to-graph converter, plus anything I point the local command at. It hasn’t reviewed a sampler node or a CUDA path. The bugs it catches are concurrency in the inference serving layer, auth and credential handling, prototype-pollution in workflow-graph parsing, and resource-exhaustion in upload paths. That’s a deliberate scope, and it’s where our review volume actually is.

The constraints

• Flat cost ceiling, not cheap-per-PR. A per-call meter on a busy repo is a budget you find out about after it’s gone. The whole thing had to live inside one $200/mo Cursor Ultra seat. If it can blow the budget, someone eventually disables it.

• Runs in CI, not on my laptop. A review that only fires when I remember to run it is just me with extra steps.

• Not gameable by a malicious PR. The diff is attacker-controlled. If the reviewer reads its instructions from inside the PR, the PR can tell it to approve itself.

• Runs alongside CodeRabbit, not instead of it. We already use it and it’s good. I wanted a second, differently-shaped opinion, not a replacement.

Why four different labs

Here’s the mechanism. Models from the same lineage share training priors, so they share blind spots and false alarms: they flag what code of this shape usually gets wrong, not what this specific code actually gets wrong. Four of them agreeing is fake consensus, and it’s worse than a single reviewer because it feels like corroboration.

Different labs break that. As of mid-2026 the lineup is one top model each from OpenAI, Anthropic, Google, and Moonshot (Kimi), and they fail differently. One fixates on concurrency. One catches API contract drift. One notices the resource you opened and forgot to close. Three of four landing on the same line is signal worth trusting. One screaming alone is also signal: it’s the finding a same-lineage reviewer would never surface.

Here’s a real one. A change wired up image editing for two different providers, and two reviewers each caught a bug the other three missed, including each other’s. Claude alone noticed that one provider’s model accepts a single image, not the several the code allowed: ask for a multi-image edit and it would fail deep in the provider call with a confusing error instead of a clean rejection up front. On the same diff, GPT-5 Codex alone noticed the code quietly dropped a content-moderation setting, so anyone who turned safety filtering up would have silently gotten the default instead. Four models from one lab would have nodded along and shipped both.

The obvious objection: isn’t this just ensemble variance? Wouldn’t four runs of one strong model, at different temperatures with different prompts, catch the same things? Some of them, sure. But temperature resamples the same distribution. It reshuffles confidence inside one set of priors; it doesn’t add the prior that catches the dropped moderation default when the other three are structurally blind to it. The blind spots live in the training, not the sampling. I haven’t run the clean experiment (four-temperature-of-one versus four-labs on a labeled set) and I’d genuinely like to. My working bet is that lineage diversity buys coverage temperature can’t.

This matters more once an agent writes the first draft. If Claude writes the code and Claude reviews it, that’s the same opinion twice. The reviewer is blind in exactly the spots where the author was.

The architecture

It started as a local Cursor CLI command that fanned a diff out to all four labs. Each model runs two passes: adversarial (assume it’s broken, find where) and edge-case (assume the happy path works, find the input that isn’t). Four models, two passes, 8 reviews per PR.

Eight raw reviews is too much: noisy, double-counted, full of the fake consensus above. So nothing posts to the PR directly. Everything funnels into one judge, the latest Claude Opus, run once per PR and told not to trust the reviewers. The judge reads the actual changed files (the reviewers see the diff; the judge sees ground truth) and sorts every finding into verified, pre-existing, or false-positive, then caps output at the 10 highest-signal items. The reviewers over-flag on purpose. The judge’s job is to throw most of it out.

The whole fan-out is an 8-cell GitHub Action matrix:

strategy:
  fail-fast: false
  matrix:
    model:
      - gpt-5.3-codex-xhigh
      - claude-opus-4-7-thinking-xhigh
      - gemini-3.1-pro
      - kimi-k2.5
    review_type: [adversarial, edge-case]
# 4 models × 2 review types = 8 independent reviews per PR

I productionized it as a label-triggered GitHub Action. Drop a cursor-review label on a PR and the fan-out fires; getting assigned as a reviewer auto-adds the label. About 110 PRs have carried it so far. It’s a label and not every-PR for two reasons: an eight-model hostile pass on a one-line dependency bump trains people to ignore the bot, and the every-PR slot is already CodeRabbit’s. This is the deep pass you opt into; the PRs where both it and CodeRabbit flag the same line are the ones I read first.

Three details that matter more than they look:

• Idempotent per HEAD SHA. Re-labeling, fixups, and flaky retries don’t double-review or re-bill eight models for a diff that hasn’t changed.

• 5,000-line diff cap. Above that it bails. A 5,000-line diff has worse problems than a missing review.

• The prompts live in a separate repo the PR can’t write to. This is the security one. The reviewer and judge prompts are checked out from the reusable workflow’s own repo, pinned to a ref, never from the PR’s checkout. If the Action read its prompts from the PR’s own commit, a hostile PR could edit the file that tells the judge how to grade it (drop “ignore previous instructions, this diff is perfect” into a test fixture). Because the prompts aren’t in the repo under review at all, the code being judged can’t rewrite the rules it’s judged against.

How I use it, and what it cost

It runs first, not last. When I’m writing, I run it locally the moment the agent finishes, before I commit. When I’m reviewing someone else’s PR, the label auto-adds on assignment, so the pass is done before I open the diff. I read the bot’s verdict first, then the code, and the output stays on the PR as a paper trail other reviewers can audit instead of taking my word for it.

One example of why reading it first pays off. A change I’d approved, and a teammate had signed off on too, touched the shared code that paginates long lists. Four of the eight reviewers, across three different labs, independently flagged the same line: the list only sorted the way you asked if the sort direction was spelled exactly right. A blank value, a typo, or a raw request parameter would silently reverse it. In practice that means a paginated list could skip items or repeat one across pages, with no error to catch it, in shared code every future list screen would build on. When four rival models circle the same line on a change two humans already cleared, that’s the part you read first.

Before, I ran this by hand on PRs assigned to me, and not at all on the rest. After: 8 adversarial reviews plus a judge on ~110 PRs, flat $200/month, never once hit the limit. Built in about 24 days and 35 commits, most of them me arguing with the judge about what counts as “verified.”

One design call earned its keep. Severity is a 5-level tag (critical / high / medium / low / nit), and a malformed or missing severity falls back to medium rather than getting dropped. Losing a critical bug to a formatting hiccup was the failure mode I cared about most.

It also stopped being mine. It’s a shared Action, so anyone drops the label and gets the same pass, no install, no asking me. It went from a private hack to team infrastructure the day another engineer saw the comments on my PRs and asked to put it on the frontend repo.

What’s still open

• The lineup rotates. “Top model from each lab” is a moving target. Four-different-labs is the durable part, not the roster, which is why it’s one config change in a shared repo that every consumer picks up on the next run.

• The judge’s cap of 10 is a heuristic. Sometimes a PR has 14 real problems and 11 through 14 get truncated. Ten is a vibe that’s held, not a number I derived.

• The judge is a Claude model, same house as one of the four reviewers. LLM judges show measurable self-preference, so it could over-weight the Claude reviewer. Working from the real files limits this, but I haven’t fully closed it.

• None of this is benchmarked. No held-out labeled bug set, no precision/recall, no controlled one-lab-versus-another comparison. What I have is ~110 PRs of lived experience and real bugs it caught that humans (me included) had waved through. Engineering judgment backed by results I trust, not a study you should cite. Benchmark it properly and I’d like to see the numbers.

The architecture is the contribution, so the prompts and the workflow are open:

Cursor Review G itHub Workflow →

Take it, run it on your own PRs, and tell me where the judge cap is wrong. We open-source how we work because the engineers we want are the ones who read this and immediately want to argue with the design. If that’s you, come build with us →.

Big day for the open-source community! Ideogram just dropped their first open-weights foundation model, Ideogram 4.0, and it’s natively supported in ComfyUI on day zero.

It is a 9.3B parameter text-to-image model trained from scratch. If you have been waiting for an open model that can handle posters, layouts, and readable copy without sending prompts to a closed API, this is the one to try.

Try on Comfy Cloud

Download Workflow

Precise control with structured JSON prompting

This is where Ideogram 4.0 earns its keep. A plain-text prompt gets you an image; the JSON surface gives you control. Three things you can do that a flat prompt can’t:

• Color palettes: Up to 16 hex colors per image (5 per element).

• Bounding-box layout: [y_min, x_min, y_max, x_max] in 0–1000 normalized coordinates.

• Typed text elements: Literal string to render, plus a separate styling description.

Pro tip: the more relationships you pin down in the caption (positions, colors, per-element styling) the more grounded the result. The model was trained on exhaustively described scenes, so it rewards specificity.

JSON Prompt Structure Template:

{
  "high_level_description": "",
  "style_description": {
    "aesthetics": "",
    "lighting": "",
    "photo": "",
    "medium": "",
    "color_palette": []  # hexadecimal values
  },
  "compositional_deconstruction": {
    "background": "",
    "elements": [
      {
        "type": "obj",  # for object
        "bbox": [],  # y_min, x_min, y_max, x_max
        "desc": "",
        "color_palette": []  # hexadecimal values
      },
      {
        "type": "text",  # for text
        "text": "",  # the text to render
        "bbox": [],  # y_min, x_min, y_max, x_max
        "desc": "",
        "color_palette": []  # hexadecimal values
      }
    ]
  }
}

Examples

Safety Filtering

Ideogram 4.0 ships with its own built-in safety filter that lives inside the model itself, this is not a ComfyUI filter. If a generation gets blocked or returns a blank/refused result, that’s the model’s own filter engaging, not anything ComfyUI is adding or controlling. We can’t tune, disable, or override it from our side, since it’s baked into the model’s weights as released by Ideogram. If you hit a block you didn’t expect, try rephrasing your prompt or adjusting the offending element rather than filing it as a ComfyUI bug.

Getting Started

1. Update ComfyUI to the latest version 0.24.0 (Cloud and Desktop will follow soon)

2. Download the workflow below, or find it in the template library

3. Follow the note in the workflow to download models and save them in the correct model directory

4. Use a natural language prompt or write your prompt in JSON format, then run the workflow

Try on Comfy Cloud

Download Workflow

Model weights: 🤗 Comfy-Org/Ideogram-4
GitHub repository: ideogram-oss/ideogram4

As always, enjoy creating!

If you blinked, here’s the catch-up.

In May we integrated 11 new models spanning video, image, 3D, audio, and multimodal.

Here’s what’s new.

Krea 2 — Krea AI · Image & Style Transfer

• Krea’s first foundation model, live as a ComfyUI Partner Node on day one. Most image models compete on what’s in the frame. Krea 2 competes on how it looks — style references, moodboards, and aesthetic range across illustration, anime, photorealism, and beyond.

Void — Netflix · Video Object Removal

• Netflix open-sourced VOID (Video Object and Interaction Deletion). Most inpainting tools erase pixels. VOID removes the subject and everything it caused — shadows, reflections, physical interactions. Apache 2.0, natively supported.

Tripo 3.1 — Tripo AI · 3D Generation

• Text-to-model, image-to-model, and multiview-to-model in one node. Pair it with TripoSplat and you have a full image-to-3D-Gaussian pipeline, end to end.

Luma UNI-1 — Luma AI · Image Editing

• Not a diffusion model. Luma’s Uni-1 is a decoder-only autoregressive transformer — it reasons through your prompt before generating. Stronger reference handling, more precise editing. Create and Modify modes, up to 9 reference images. One of the most architecturally interesting image models of the year

Claude — Anthropic · Multimodal

• Claude is now accessible inside ComfyUI. Prompt writing, workflow reasoning, multimodal understanding — language intelligence anywhere in your pipeline.

OpenRouter · Text

• Access to 20+ LLM models through a single node. Route to the right model for the right task without leaving your workflow.

Gemma 4 — Google DeepMind · Multimodal

• Google’s best open model family yet. Text, image, audio, and video — runs on a phone or a single GPU. The 31B model sits at #3 on the open Arena leaderboard. Apache 2.0, 256K context window.

HidDream-O1-Image — Hidream.ai · Image

• Reasoning-guided image generation. Open source model built on a Pixel-level Unified Transformer (UiT) without external VAEs or disjoint text encoders. Strong on complex compositional prompts where most models fall apart.

Stable Audio 3 — Stability AI · Audio & SFX

• Text-to-audio covering music, sound effects, and production-ready audio. Your sound design toolkit, now in ComfyUI.

BiRefNet — CAAI AIR · Background Removal

High-resolution background segmentation. Pairs naturally with VOID — BiRefNet handles stills, VOID handles motion.

MoGe — Microsoft · 3D Geometry & Depth

• Full 3D geometry from a single image — point maps, depth, normals, and camera FOV in one forward pass. A CVPR ‘25 Oral, now in your toolkit.
  

ComfyHub is gaining momentum

• Crossed 500+ workflows on the Hub

• If you haven’t browsed lately, there’s a good chance someone already built the workflow you were about to make.

Stay tuned for June!

TripoSplat is especially good at stylized subjects such as characters, props, and creative designs where look and detail matter. Unlike many 3D generators that produce the same amount of detail everywhere, TripoSplat leverages a novel approach for adaptive density control, to put more detail where your image needs it and stay lighter on simple areas, so you get optimal results without wasting file size or rendering cost.

Download Workflow

Highlights

• Open source (MIT): weights and inference code are available for local runs, customization, and community workflows.

• One image in, 3D splat out: no multi-angle photo shoot required.

• Smarter detail placement: richer geometry where it counts, simpler where it does not.

• You choose the detail level: use fewer Gaussians for background props, more for hero assets, or export several versions for different devices (like level-of-detail in games).

Where It Fits

• Modern 3D pipelines: 3D previews for stylized characters, environments, props, and creative designs.

• 3D-to-2D guidance: block out a 3D concept, product, or scene and render it to guide image or video generation.

• AR/VR & interactive: turn a concept image into something you can explore in 3D.

Examples

Get Started in ComfyUI

1. Update ComfyUI to the latest version v0.23.0 (Cloud and Desktop will follow soon)

2. Open the Template Library and search for TripoSplat.

3. Choose the TripoSplat workflow template.

4. Follow the instructions in the template to download the models

5. Upload an image, then run the workflow

Download Workflow

Model weights: 🤗 VAST-AI/TripoSplat
Inference code: VAST-AI-Research/TripoSplat

We look forward to seeing what you build with TripoSplat.
As always, enjoy creating!

​

Krea’s first foundation image model with tunable creativity, style references, and moodboard conditioning — lands in ComfyUI as a Partner Node.

The Krea 2 Image node ships with prompt, model, aspect ratio, creativity, moodboard, seed, and an optional style reference image input. It’s Krea’s first foundation image model, trained from scratch and designed around giving you direct control over the look and direction of every output.

Krea 2 - Text to Image Workflow

Model Variants

The node exposes two models: Krea 2 Large and Krea 2 Medium. Both support the same parameters and feature set. The differences come down to model size, post-training, and the character of the outputs.

Krea 2 Medium is the smaller, faster, more cost-efficient option. Heavier post-training makes generations more stable and consistent run-to-run. Particularly strong on illustration, anime, painting, and other expressive styles.

Krea 2 Large is more than twice the size, with lighter post-training. Outputs feel rawer, more textured, and more flexible. It handles expressive work well and is the stronger pick for photorealism and “raw” looks.

Aesthetic diversity

Krea 2 spans a wide range of visual styles, with notable strength in artistic and expressive directions that other models tend to smooth into a generic look. Useful when you want output that doesn’t read as obviously AI-generated.

Style transfer

Pass a reference image into the style_reference input on the node, and the model extracts the style and applies it to your generation. This feature is a highlight of the model and definitely a leading model in the style transfer realm.

Creativity

creativity is an exposed parameter, with four modes: Raw, Low, Medium, and High. At higher settings the model adds aesthetic depth, interpretation, and visual richness to whatever you give it. Drop it for tighter prompt adherence. This is the lever for trading off literal interpretation against the model’s own aesthetic.

Moodboards

Moodboards are the most precise way to direct Krea 2 visually. A moodboard is a group of images that share a creative direction. Build the moodboard on the Krea’s website, copy the ID, and paste it into the moodboard_id field on the node. The moodboard_strength slider controls how strongly the direction is applied. Even simple prompts produce dramatically different outputs depending on the moodboard attached. For art direction or studio workflows where consistency across a body of work matters, this is the primary control.

Getting Started

1. Update ComfyUI to the latest version, or access Comfy Cloud.

2. Find the Krea 2 Image node via the Node Library, or load a template from the Templates panel.

3. Drop in your prompt (and a source image if you’re using style reference), connect outputs, and run.

Try it on Comfy Cloud

We’re excited to share that Stable Audio 3.0—Stability AI’s new family of music models built for artistic experimentation—is coming to ComfyUI. Trained on fully licensed data, these models bring variable-length generation, on-device-friendly small checkpoints, and stronger musicality for longer structure—so you can go from quick SFX to extended tracks inside the workflows you already use.

Download Workflow

Model highlights

• Licensed for commercial use — trained on fully licensed music data.

• Flexible clip length — from quick SFX and short loops to longer tracks (up to about two minutes on Small, six minutes on Medium).

• Lightweight, small models — run Small SFX and Small music on a CPU, no big GPU required.

• Medium for longer music — fuller tracks with stronger structure when you have a GPU.

Available Models

• Small-SFX: Sound effects and short ambiance, up to 2:00,

• Small-Music: Short music and on-device-friendly loops, up to 2:00

• Medium: Longer tracks with stronger structure and musicality, up to ~6:20

Small reaches two minutes (vs. 11s / 47s on Stable Audio Open). Medium goes beyond six minutes when you need length.

• 🤗 Stabilityai/stable-audio-3

• 🤗 Comfy-Org/stable-audio-3 (for ComfyUI)

Examples

Music

A short idea for a complete piece (genre, instruments, mood, length).

Lo-fi hip-hop chill track with mellow electric piano, soft vinyl crackle, subtle synth pads, low-pass filtered drums, percussion loops, and soft plucked bass for a relaxed, dreamy vibe. BPM: 75. Length: 150 seconds

Synthwave 80s retro track with arpeggiated synth leads, analog pads, electric bass, punchy electronic drums, gated reverb snares, and atmospheric FX for nostalgic and vibrant energy. BPM: 110. Length: 180 seconds

Instrument

Single-instrument or small-group clips for production and scoring.

Guitar muted strum loop with tight rhythmic feel. BPM: 100. Length: 8 seconds

Pluck sequence loop with bright resonant tone. BPM: 128. Length: 10 seconds

Sound effects and ambience

Impacts, textures, environments, and motion sounds for pictures and games.

Footsteps on gravel, steady walking pace, close perspective. Length: 8 seconds

Car speeding past at high velocity, doppler effect, realistic whoosh. Length: 3 seconds

One-shot

Brief isolated sounds for drums, UI, transitions, and sample libraries.

Bass pluck with jazzy tone and resonant wooden body. Length: 3 seconds

Latin drums, dynamic Latin drums and percussion ensemble featuring authentic rhythmic patterns. Length: 3 seconds

Get started

1. Update ComfyUI to v0.22.0 or go to Comfy Cloud

2. Go to the left sidebar → Template → Audio category → Choose Stable Audio 3.0 Template

3. For local users, please follow the note in the workflow to download the models and place them in the correct directory

4. Write a prompt, set the duration in seconds, then hit run.

Stable Audio 3.0 Medium Base Workflow

Stable Audio 3.0 Medium Workflow

As always, enjoy creating!

​

Big week for our open-source community! We’re excited to announce native ComfyUI support for three newly open-sourced models this week: Netflix’s VOID for video object removal, BiRefNet for high-resolution background segmentation, and Google’s Gemma 4 multimodal LLM. Here’s a look at what each one does and how to get started.

VOID: Video Object Removal with Accurate Physical Interactions

Netflix recently open-sourced VOID (Video Object and Interaction Deletion), a video inpainting model that goes further than simply erasing pixels. When you remove a subject, VOID also removes everything that subject physically caused in the scene: shadows, reflections, and objects that were set in motion by its presence.

The key to getting good inpainting is quadmask: instead of a standard binary mask, VOID takes a greyscale mask using four values that tell the model which regions to remove, which overlap, which are physically affected, and which to keep untouched. This lets the model reason about cause and effect rather than just filling in a hole. Pro tip: use video segmentation models such as SAM3 to generate initial mask input for quadmask.

VOID ships with two checkpoints. Pass 1 handles the base inpainting and is sufficient for most clips. Pass 2 adds optical flow-warped refinement for better temporal consistency on longer or more complex footage.

Getting Started

1. Update ComfyUI to the latest version, or visit Comfy Cloud

2. Download the model package from Comfy-Org/void-model and place the files in the correct model folders

3. Download the workflows below, or find them in the template.

4. Prepare your input video, quadmask, and a text prompt describing the scene after removal, then run the workflow

Try on Comfy Cloud

Download Workflow

BiRefNet: High-Resolution Background and Object Segmentation

BiRefNet (Bilateral Reference Network) is a segmentation model from CAAI AIR 2024 that has become one of the most widely used image segmentation backbones in the open-source ecosystem.

BiRefNet is built for dichotomous image segmentation, extracting clean, high-resolution masks from complex images including fine detail like hair, fur, and transparent surfaces. The same model also handles salient object detection and camouflaged object detection, so it covers a wide range of masking tasks in a single lightweight package.

Getting Started

1. Download the model package from Comfy-Org/BiRefNet and place birefnet.safetensors in your models/background_removal/ folder

2. Download the workflows below, or find them in the template.

3. Drop in your image and run

Try on Comfy Cloud

Download Workflow

Gemma 4: Google’s Multimodal Reasoning Model

Google DeepMind has released Gemma 4, the latest generation of their open-weights model family. Gemma 4 is natively multimodal -- handling text, image, audio, and video input -- and includes a configurable thinking mode that lets the model reason step by step before producing a response

Gemma 4 models are out on ComfyUI as text encoders to be used with TextGenerate node. Two variants are available: E2B and E4B are parameter-efficient models and a good starting point for most consumer GPUs. Additionally, two more variants, the 26B A4B Mixture-of-Experts and 31B dense models, are available through Google’s official release.

Getting Started

1. Download the model package from Comfy-Org/gemma-4 and place the files in your models/text_encoders/ folder

2. Download the workflows below, or find them in the template.

3. Type in text instructions, wire in any optional images or videos, and run

Try on Comfy Cloud

Download Workflow

As always, enjoy creating!

We’re excited to announce support for Tripo 3.1 in ComfyUI via Partner Nodes. You can now generate high-detail 3D assets directly in your existing ComfyUI workflows, with better geometry density and surface quality for close-up production use.

Built for hero-level assets, Tripo 3.1 helps creators move from concept to usable models faster, whether the target is game production, marketing visuals, product rendering, or 3D printing pipelines.

Try on Comfy Cloud

What’s New with Tripo 3.1

Tripo 3.1 focuses on detail quality that holds up in real production scenes:

• High-density geometry for sharper edges, cleaner silhouettes, and more precise forms.

• PBR-ready material behavior for more reliable lighting response across render environments.

• Hero asset quality that remains stable in close-up shots.

• Cross-scenario reuse so one model can work across gameplay, promo, and render workflows.

Examples

Text to Model

Try on Comfy Cloud

Download Workflow

Image to Model

Try on Comfy Cloud

Download Workflow

Multiview to Model

Try on Comfy Cloud

Download Workflow

Typical Use Cases

After setup, here are common production scenarios where Tripo 3.1 works especially well:

• Game hero assets for close camera shots and promotional key art.

• Marketing visuals where geometric fidelity and material quality are critical.

• Product visualization for cleaner shape definition in studio-style renders.

• 3D printing preparation, where better structural clarity improves handoff quality.

We look forward to seeing what you create with Tripo 3.1 in ComfyUI.

As always, enjoy creating!

​

Luma’s Uni-1 is now available in ComfyUI via Partner Nodes. Unlike most image models, Uni-1 isn’t a diffusion model — it’s a decoder-only autoregressive transformer that treats text and images as a single interleaved sequence, jointly modeling time, space, and logic in one architecture. The result: a model that reasons about your prompt before generating — decomposing instructions, resolving constraints, and planning composition like a frontier LLM.

Try it on Comfy Cloud

Built around reasoning, not just generation

Most image models go straight from prompt to pixels in a single step. Uni-1 works differently. It thinks first, then draws.

Because Uni-1 is autoregressive and treats text and images as the same kind of sequence, it can reason through your prompt before generating anything. It breaks the instruction into parts, works out the tricky bits (how many of something, what goes where, any logical conditions), and plans the composition — all before committing to pixels.

Features

• Photorealism with material accuracy

• Text rendering that’s actually readable

• Reference-guided generation with identity preservation

• Image editing and multi-turn refinement

• Multi-panel output with temporal consistency

• Web search grounding

• Multilingual prompts

Output flexibility

Uni-1 supports 9 aspect ratios ranging from 3:1 ultra-wide panoramic banners down to 1:3 ultra-tall portrait formats, with everything in between — 16:9, 1:1, 9:16, 2:3, and more.

Getting Started

1. Update ComfyUI to the latest version, or access Comfy Cloud.

2. Find the Luma UNI-1 Image node via the Node Library, or load a template from the Templates panel.

3. Drop in your prompt (and a source image if you’re editing), connect outputs, and run.

Try it on Comfy Cloud

UNI-1 joins the growing roster of image models available through ComfyUI Partner Nodes. Try it out and let us know what you build.

Bye April! We shipped a ton of new models, features and expanded our Comfy Hub.

If you blinked, here’s the catch-up.

New models

Seedance 2.0

• ByteDance’s next-gen video model, live as a partner node on day one.

• Three modes out the gate: Text-to-Video, Reference-to-Video, and First/Last-Frame to Video, pick your level of creative control.

• Upload an AI-generated image or a Real human portrait, then create videos with a consistent identity and authentic facial expressions.

Happy Horse

• A multi-talented partner node covering Text-to-Video, Image-to-Video, Reference-to-Video, and video editing.

Wan 2.7

• The latest in the Wan 2.7 multi-use case video model is available as a partner node

Ernie-Image

• Baidu’s open-source text-to-image model built on8B Diffusion Transformer (DiT).

• Fully open weights for the folks who like to tinker

Ace Step 1.5 XL

• Open-source music generation, but commercial-grade quality.

• Tuned for full-song coherence: verses, choruses, and arrangements that actually hold together.

Quiver

• Structured SVG generation as a partner node: vector output, not pixels.

• Great for icons, diagrams, and anywhere you need infinite scalability without re-rendering.

GPT Image 2

• OpenAI’s latest image model available via partner node.

• Both text-to-image and editing in a single workflow

SUPIR

• Open-source image restoration support: bring blurry, degraded, or low-res images back to life.

• Pairs nicely with anything you’d run through an upscaler

RIFE & FILM Frame Interpolation

• Open-source frame interpolation, now natively supported.

• Use it to smooth motion, hit higher frame rates, or stretch short clips into something cinematic.

SAM 3 & SAM 3.1

• Meta’s SAM 3 and SAM 3.1 models for image and video segmentation are now natively supported

Veo 3.1 Lite & Veo 3.1 Fast

• Google’s lighter and cheaper Veo variants are now partner-node supported.

Sonilo

• Video-to-music, now inside ComfyUI.

• Drop in a clip, get a soundtrack tuned to its motion and mood.

Feature releases

Parallel Job Execution through API

• You can now run multiple workflows in parallel — a serious speedup for anyone batching, testing variations, or running production pipelines.

• The single feature most likely to change how your day actually feels.

ComfyHub is gaining momentum

• Crossed nearly 500 workflows on the Hub.

• If you haven’t browsed lately, there’s a good chance someone already built the workflow you were about to make.

Excited about May!

We’re excited to share that ComfyUI now supports HappyHorse 1.0 — a cinematic video generation model from Alibaba, designed for high-quality storytelling video and production-ready creative workflows.

HappyHorse 1.0 focuses on strong aesthetics, multi-shot sequencing, and powerful edit-style workflows (generation + editing). It’s a great fit for creators building ads, e-commerce visuals, short-form content, and social marketing videos.

Try on Comfy Cloud

Highlights

• Multi-modal creation paths: Text-to-Video (T2V), Image-to-Video (I2V), and Subject-to-Video (S2V).

• Cinematic aesthetics: Wide-aperture framing, shallow depth of field, refined texture, and atmospheric mood.

• Multi-shot output: Up to 15s at 1080p, with an emphasis on multi-shot consistency across cut transitions.

• Editing workflows: V2V and SV2V for transforming footage or replacing/inserting subjects while preserving motion and composition.

Output Examples

Get Started in ComfyUI

1. Update to the latest ComfyUI or visit Comfy Cloud

2. Open Template Library → Search for HappyHorse

3. Update prompt or input image, then hit Run

Available workflows

Image to Video

Try on Comfy Cloud

Text to Video

Try on Comfy Cloud

Video Edit

Try on Comfy Cloud

Reference to Video

Try on Comfy Cloud

As always, enjoy creating!

We’re announcing a $30 million financing at a $500 million valuation, bringing our total funding to $47 million. The round was led by Craft, with participation from Pace Capital, Chemistry, TruArrow and others.

ComfyUI started as a community project: one developer, one open-source repo, and a fast-growing group of creators who wanted more control over how they created with AI. That community now spans 4 million users, 60,000+ nodes built by contributors, and 150,000+ daily downloads. This round is a reflection of what that community has built together.

ComfyUI is already the best software for creative AI but now we can make it even better: more features, more optimizations and more stability while accelerating our already rapid pace of development.

“With this funding we can make sure open source wins.” said Yannik Marek, cofounder and the creator of ComfyUI, “We and many in the community have spent a lot of effort: countless hours, even years working directly and indirectly on ComfyUI. Without you we would not exist. We want to live in a world where the best tool is open source. Now we can finally make our dream real.”

How professional creators are using ComfyUI

ComfyUI has become the standard for creator-controlled AI workflows, spanning image, video, 3D, and audio, locally or in the cloud. Studios, agencies, and enterprise teams are using it to power production-grade creative pipelines.

Creative studios like Black Math are using ComfyUI to build modular creative pipelines connecting their motion, texture, and generative tools in ComfyUI enabling teams to move beyond one-off deliverables and instead create scalable design systems that clients can build on over time.

Agencies & Ad studios like Silverside AI use ComfyUI to power major brand campaigns, for example, developing SVEDKA’s 2026 Super Bowl commercial, the first primarily AI-generated Super Bowl ad. This enables precise creative control, consistent quality, and faster production timelines.

Technical artists use ComfyUI the way engineers use code, composing models, LoRAs, ControlNets, and community nodes into precise, reproducible workflows. A concept artist chains an image generation model to a depth estimator and an inpainting pass, so every iteration preserves geometry while exploring style. A VFX freelancer builds a texture synthesis pipeline that processes hundreds of assets overnight. When the workflow is done, it lives in a JSON file: portable, versionable, shareable.

“ComfyUI is so important to us because it allows us to know that we always play on the bleeding edge. Not only because of the technology itself, but because of the entire community shaping the product and developing extensions,” PJ Pereira, Co-founder, Silverside AI.

“Using ComfyUI really brings artist empowerment to the forefront. I want my employees to feel like they have control over the process. The more exposed they can be to how the models work, the more we feel we’re creating something that only we could make,” Jeremy Sahlman, Co-founder & CCO, Black Math.

ComfyUI has quietly become a hiring signal. Across job boards at Enterprise companies and creative studios, “ComfyUI artist” has emerged as a job title in high demand. Creative directors, technical artists, and pipeline engineers are now expected to build in ComfyUI. What began as an open-source tool built by a single developer has become infrastructure for a new creative profession.

A community that compounds

The open ecosystem is what makes ComfyUI structurally different from any closed tool. With 60,000+ community-built nodes and extensions, every new model, every new technique, every workflow shared publicly makes the platform more powerful for everyone. No product team could ship that fast. No single company could cover that much ground.

And the platform only grows stronger as more creators build on it, extend it, and push it in directions we never anticipated.

“Comfy has innovated a new and powerful ecosystem for creativity without compromising creative control. It has been amazing to watch technical artists and curious creative minds leverage Comfy to explore the full surface area of their ideas,” Scott Belsky, Founder of Behance.

What we’re building next

We’re already one of the most widely used platforms for generative AI. But we think ComfyUI can be the best creative engine for professionals. Period. Here’s where the funding goes:

• Comfy Cloud, built for teams

  • We’re scaling cloud infrastructure to bring ComfyUI to creators who don’t have access to high-end local compute, and to studios that demand security and infrastructure out of the box.

• Collaborative workflows

  • Creative work is rarely solo. We’re building the features that let teams share, version, and iterate on workflows together so the way ComfyUI works in a studio finally matches how studios actually work.

• Investing in local experience

  • The power was always there. We are continuing to invest in Comfy Local and making updates a seamless and stable experience

• Ecosystem stability

  • 60,000+ community nodes are one of ComfyUI’s greatest strengths. We’re investing in the infrastructure and standards that make them more reliable on Local and Cloud and easier to build.

• Model support, always current

  • Every major model release should work in ComfyUI on day one. We’re building the integrations and partnerships to make that a guarantee.

We are not building a walled garden. We are building open infrastructure, the kind that lasts, the kind that empowers rather than locks in.

Why join us

ComfyUI is built by a team of engineers and operators who don’t do average. We’re solving hard problems at the intersection of creative tooling, ML infrastructure, and distributed systems, problems that matter to millions of people who create things for a living.

If you want to build tools that technical artists and studios depend on every day, if you’re the kind of engineer who gets excited when a community of 4 million people finds unexpected ways to use what you’ve built, you should be here.

Thank You to our community

None of this exists without you.

The 60,000+ nodes you’ve built. The workflows you’ve shared. The bugs you’ve filed, the fixes you’ve submitted, the tutorials you’ve posted.

ComfyUI exists because of you. The funding, the valuation, the enterprise adoption, all of it traces back to a group of people who cared enough to build something together, in public, for anyone to use.

What we’re committing to: the ComfyUI will always stays open. You will always be able to run ComfyUI on your own machine, on your own terms, with full access to everything you’ve built. Open source lasts forever, and we intend to prove it.

This round gives us the resources to go further: better infrastructure, better tooling, more support for the ecosystem you’ve created. We’ll keep building in the open, keep listening, and keep getting out of the way when the community knows better than we do.

Thank you. Genuinely.

Team Comfy

We’re excited to share that you can now generate videos featuring Virtual Portraits & Real Humans with Seedance 2.0 in ComfyUI. Upload an AI-generated image or a Real human portrait, then create videos with a consistent identity and authentic facial expressions.

Try on Comfy Cloud

Virtual Portrait VS Real Human: What’s the difference?

Real Human refers to actual living people (needing verification), while Virtual Portrait is AI-generated and non-existent in reality (no verification needed).

How to use Virtual Portrait for Seedance 2.0

To use a virtual portrait with Seedance 2.0, use the Seedance 2.0 node as the regular video generation node, upload your AI-generated character asset, and then pass it to the node.

The ByteDance server will detect the image type and throw an error if it’s identified as protected content. If the backend identification has passed, then you can use it as a reference asset without any issue.

Try on Comfy Cloud

How to use real human assets for Seedance2.0?

The verification process is designed to prevent impersonation and unauthorized use of someone’s likeness. It’s handled by ByteDance, which complies with emerging AI transparency regulations.

First Run (Verification Required)

1. Upload a portrait image using the ByteDance Create Image/Video Asset node

2. Run the workflow—a verification link will be generated

3. Open the link on your phone or browser and complete the liveness check (less than 30s)

4. Real human verification passed. You will receive two IDs:

• Group ID — represents the verified person (save this)

• Asset ID — this specific image, ready to use in video generation (point to the same asset, can be reused as well)

Future Image with the same person (No Verification)

1. Upload a new photo or video of the same person

2. Enter the saved Group ID in the ByteDance Create Image/Video Asset node

3. The system compares facial features against the original verification

4. If it matches, the new asset is activated automatically

Getting Started

Try on Comfy Cloud

Download Workflow

1. Update ComfyUI to the latest version, or visit Comfy Cloud

2. Go to Template Library → search Seedance 2.0

3. Update the input and follow the guide in this blog

As always, enjoy creating!

What is Seedance 2.0?

Seedance 2.0 is ByteDance’s latest video generation model, built for industrial-grade controllability and native audio-video sync. With Real Human support in ComfyUI, you’re no longer limited to virtual characters—you can bring those same strengths to videos featuring real people, with identity and performance held together across a full clip.

• Real people, cinematic control: Direct camera moves, lighting, and scene changes while keeping the subject believable.

• Identity consistency: Keeps facial features and overall appearance stable across motion, camera moves, and transitions.

• Native audio-video sync: Generates video and audio together (dialogue/ambient/music) with more reliable lip-sync and expressions.

• Multi-reference directing: Mix text with up to 9 images, 3 videos, and 3 audio clips to lock in look, motion, and rhythm.

Check more details in our documentation

​

Try on Comfy Cloud

Reasoning-Driven Generation

GPT Image 2.0 is built around a thinking step. Instead of one-shot sampling, the model plans the composition, checks its work, and iterates — which is why it handles the things that have historically broken image models. Dense text, small UI elements, iconography, infographics, maps, slides, even manga panels render cleanly. For ComfyUI users, this means you can finally ask for “a poster with a seven-item bulleted list in 11pt Helvetica, centered” and get usable output instead of glyph soup.

Try on Comfy Cloud

Image Editing That Preserves What Matters

Edit-based workflows have been a weak spot across every major image model — small changes tend to ripple outward, warping faces, altering composition, or quietly rewriting details the user never asked to touch. GPT Image 2.0 handles targeted edits with structural fidelity, keeping everything outside the edit zone pixel-stable while applying the requested change cleanly at up to 2K resolution. Colorizing a black-and-white photo or shifting a scene from noon to dusk both land cleanly, without the usual collateral damage to faces, geometry, or fine detail. For retouching workflows, archival restoration, or iterative creative direction, this is a meaningful unlock.

Try on Comfy Cloud

Eight Consistent Images, One Prompt

The model can return up to eight distinct images from a single prompt while preserving character and object continuity across the series. Storyboarding, reference sheets, character turnarounds, and product variants that used to require careful seed-locking and prompt gymnastics now come out of one node. Feed the batch straight into a Save Image loop or chain it into video workflows downstream.

Getting Started

1. Update ComfyUI to the latest version v0.19.4, or visit Comfy Cloud

2. Find the node — search for OpenAI GPT Image 1.5 in the Node Library. Select the gpt-image-2 model.

GPT Image 2.0 slots naturally into hybrid pipelines: use it for the text-heavy hero frame, then hand off to your local models for upscaling, stylization, or video. That’s the point of Partner Nodes — the best model for each step, in one graph.

Let us know what you build.