← billmoore.ai

Open source · MITClaude Code + ComfyUI, on Comfy Cloud or RunPod

remote-
comfy.

A contact sheet of 24 images from one batch: buildings, objects, food, animals, machines and illustrations
Pl. 1 One batch of 24 images, rendered with FLUX.2 [dev] on one rented L40S in 21 minutes.

An agentic toolkit for working in ComfyUI through Claude Code. Ask Claude for an asset and it picks a current model, builds the ComfyUI workflow, runs it on Comfy Cloud or on a GPU it rents on RunPod, and saves the result in your project. You do not install ComfyUI or look after a GPU.

What
It is a Claude Code skill, a ComfyUI client, a model catalogue, tested example workflows, and tools that rent RunPod pods and shut them down when the work stops.
Needs
It needs Python 3.9 or newer, ssh, bash, and a RunPod account with credit or a paid Comfy Cloud plan.
For
It is written for Claude Code and other coding agents, and every step also works by hand.
Status
This is version 0.1. It last ran on a live pod on 15 November 2026, and on Comfy Cloud on 20 November.
github.com/chickensintrees/remote-comfy

1

Use it

Paste this line into Claude Code. It clones the repository, runs the offline checks and installs the skill, and it asks before it changes anything outside that folder.

Set up remote-comfy with me by following https://billmoore.ai/remote-comfy/install.md

Then ask for what you need in plain words, such as “cut the background out of these product shots” or “make a 3D model of this photo”. You type your API keys into your own terminal, so they never pass through the chat. Nothing is rented until you ask for a pod. To set it up by hand, follow the quickstart in the README.

More of the 24-image batch in section 3. Each one took 45 seconds on one rented L40S.

2

How it works

You ask Claude Code for an asset. Claude does the work with the tools in this repository and brings the file back to your project.

  1. 1Ask

    You say what you need: a batch of images, an edit, a video clip, a cutout, a depth map or a 3D model.

  2. 2Choose

    Claude checks which models exist today and picks one from the catalogue that fits the task, the licence and the memory.

  3. 3Build

    It starts from a tested example graph or writes a new one in ComfyUI’s API format.

  4. 4Run

    Short jobs go to Comfy Cloud. Long batches, custom nodes and 3D go to a RunPod pod that it rents, sets up and shuts down.

  5. 5Return

    The files land in your project, and Claude tells you what it made.

Fig. 1 From a request to a file.

On a rented GPU

A batch runs on the pod, next to the GPUs. Your machine only rents the pod, starts the work and pulls the results home.

Fig. 2 Your machine rents the pod and pulls the results home. The watchdog on the pod stops it when the work stops, and it will not destroy a pod whose results have not come home.
  1. ACheck

    pod_ctl.py reads your balance and which GPUs are in stock before anything is rented.

  2. BRent

    It creates a pod on the cheapest GPU that fits the job, and re-reads the SSH address after every restart.

  3. CProvision

    The pod installs ComfyUI, its custom nodes and the models, and stops with an error if any file is missing.

  4. DRender

    One ComfyUI runs on each GPU, and the batch is split across them.

  5. ESync

    Each result is copied to your machine as soon as it lands.

Fig. 3 A batch from start to finish. The watchdog runs on the pod the whole time.

A Your machine2026-11-14
$ python remote_comfy/pod_ctl.py availability --min-vram 48
GPUs >= 48GB in-stock in network-volume DCs:
  CA-MTL-3   A100 PCIe(80GB,Low,$2.09), H200 SXM(141GB,Low,$5.29)
  EU-CZ-1    RTX PRO 6000 WK(96GB,Low,$2.79)
  EU-RO-1    A100 PCIe(80GB,Low,$2.09), RTX PRO 6000(96GB,Low,$2.69), B200(180GB,Low,$7.99)
  EU-SE-1    A40(48GB,Low,$0.59)
  US-NC-1    RTX PRO 6000(96GB,Low,$2.69), H200 SXM(141GB,Low,$5.29)
[9 more data centres]
B Pod: /workspace/prov.log2026-10-23
elapsed=287s
COMFY_READY
PROVISION_DONE
[pip resolver warning]
== torch trio (pinned after custom nodes) ==
torch 2.14.0+cu126 | vision 0.29.1+cu126 | audio 2.11.0+cu126
  OK flux1-dev-fp8.safetensors 17G
  OK flux1-redux-dev.safetensors 124M
  OK sigclip_vision_patch14_384.safetensors 817M
C Pod: launch log and outputs2026-10-23
comfy 8188 READY
comfy 8189 READY
SHARDED_RUN_DONE

/workspace/out:
-rw-rw-rw- 1 root root 1572424 Oct 23 18:43 harbour-0_rc_00003_.png
-rw-rw-rw- 1 root root 1058303 Oct 23 18:43 lighthouse-0_rc_00001_.png
-rw-rw-rw- 1 root root  829508 Oct 23 18:43 lighthouse-1_rc_00002_.png

/workspace/.synced.d:
-rw-rw-rw- 1 root root       0 Oct 23 18:44 _workspace_out_
D Pod: /workspace/autostop.log2026-10-23
18:36:20 watchdog up: pod=<pod> idle-limit=10min poll=30s max=1.5h lock-ttl=20min
[busy-lock lines while the batch ran]
18:43:20 lock fresh (/workspace/.busy, 99s old) - holding
18:43:50 idle 0.5min (limit 10.0)
[17 more idle lines]
18:52:50 idle 9.5min (limit 10.0)
18:53:20 stock check failed: HTTP Error 403: Forbidden
18:53:20 idle 10.0min >= 10.0min | gpu stock=None | outputs synced=True
18:53:20 stock=None: a stop would likely STRAND this pod. Outputs are synced, so terminating instead — re-provisioning is cheaper than an unreachable volume.

Fig. 4 Panel A is today's stock. Panels B to D are logs from the live test on two A40 GPUs, with the pod ID removed and repeated lines cut. Three images reached the laptop 153 seconds after launch. The refused API call in panel D is the last trap in section 7, and it is fixed.

The cost guard

The watchdog runs on the pod, so it keeps working after your laptop sleeps or the agent session ends.

Before it retires an idle pod, it checks whether the GPU type is in stock and whether every output folder has reached your machine.

WhenThe watchdog
ComfyUI has work queued, has not started yet, or a long job is holding the busy lock.Waits
ComfyUI has been idle for --idle-min, and the GPU type has high stock.Stops
The pod can be started again later.
It is idle, stock is low, and every output folder has been synced.Terminates
It is idle, stock is low, and an output folder has not been synced.Keeps billing
It does not destroy work that exists only on the pod.
The pod has run for --max-hours, 12 by default.Retires it
The same rules apply.

Or skip the pod: Comfy Cloud

Comfy Cloud runs the same graphs on Comfy’s own GPUs and bills only while a job runs, so there is no pod to set up, watch or forget. connect("cloud") and batch_harness.py --comfy cloud use it, and --inputs uploads the images a job needs.

It needs a paid Comfy plan. A run is limited to 30 minutes, or 1 hour on Pro. On 20 November 2026 it had every node and model for six of the seven example graphs; image to 3D still needs a pod. Use a pod for long batches, custom nodes it lacks, or client images that must stay on hardware you rent.

The key goes only to Comfy, never in a URL, and never with the download that Comfy redirects to signed storage.

E Your machine, Comfy Cloud2026-11-20
$ python examples/batch_harness.py \
    --comfy cloud --inputs ./inputs \
    --jobs jobs.json --out ./out
shard 0/1: 1 jobs, 0 already on disk
ok cut1  1 file(s)  4.9s
shard 0 done: 1 ok, 0 failed

3

Use cases

Everything in this section came from one rented L40S on 15 November 2026: one setup, five graphs, 40 jobs, 1.9 hours and $2.03 in total. The graphs and job lists are in the repository's examples folder.

A batch of images

Model
FLUX.2 [dev], 20 steps
Graph
flux2_dev_txt2img.json
Jobs
jobs_batch.json, 24 prompts

Pl. 1–7 One job list of 24 prompts in six themes. Each 1536×1024 image took 45 seconds; the first took 208 seconds because it loaded the models. The whole batch took 21 minutes, about $0.38. Pl. 1, at the top of the page, is the full batch.

Editing an image

Model
Qwen-Image-Edit 2511, 40 steps
Graph
qwen_image_edit_2511.json
Jobs
jobs_edit.json, 5 edits

Pl. 8–14 Each edit is the source image and one sentence, such as “Change the glaze of the teapot to matte black.” An edit took 102 seconds; the first took 201. The labels on the drawing are not real words.

Image to video

Model
Wan 2.2 I2V A14B, 20 steps
Graph
wan22_i2v_14b.json
Jobs
jobs_i2v.json, 4 clips

Pl. 15–18 Each clip starts from one image of the batch and one sentence about the motion. A 5-second clip at 832×560 and 16 fps took about 8 minutes; the first took 9. The four clips cost about $0.60. They are shown here as animated WebP at 560 pixels wide.

Image to 3D

Model
TRELLIS.2 and Pixal3D, 60,000 faces
Graph
image_to_3d.json
Runner
one image, one model per job
  1. Pl. 19Teapot, TRELLIS.2
    The input image: teapot
    The mesh from the frontThe mesh turned 90 degreesThe mesh from behindThe bare geometry, without textures
  2. Pl. 20Teapot, Pixal3D
    The input image: teapot
    The mesh from the frontThe mesh turned 90 degreesThe mesh from behindThe bare geometry, without textures
  3. Pl. 21Camera, TRELLIS.2
    The input image: camera
    The mesh from the frontThe mesh turned 90 degreesThe mesh from behindThe bare geometry, without textures
  4. Pl. 22Boots, TRELLIS.2
    The input image: boots
    The mesh from the frontThe mesh turned 90 degreesThe mesh from behindThe bare geometry, without textures

Pl. 19–22 Each mesh comes from the one image beside it, taken from the batch. TRELLIS.2 took about 170 seconds per object (the first took 534, because it loaded the models), and Pixal3D took 178 seconds on the same teapot. The grey view is the bare geometry without textures.

Cutouts and depth

Model
BiRefNet; MoGe 2
Graph
cutout_birefnet.json, depth_moge.json
Jobs
jobs_cutout_depth.json

Pl. 23–27 The cutout took 9 seconds, and a depth and normal pass took 3 to 15 seconds. These are the cheapest jobs on the page, and they run on the same pod as the rest.

Earlier: frames for a music video

Pl. 28 A 90-second layer of a music video, 554 frames at 1792×768, rendered with FLUX.2 [dev] and a turbo LoRA at 8 steps on two rented L40S GPUs in July 2026. A frame took about 82 seconds, and the layer cost about $11 in GPU time.

4

Tools

Claude drives these tools, and each one also works by hand. They use only the Python standard library, because a fresh pod has a bare Python.

  1. 01Your machine

    pod_ctl.py

    It creates, lists, stops, starts and terminates pods, and shows your balance and GPU stock.

  2. 02Pod

    autostop.py

    The watchdog stops or terminates the pod when ComfyUI goes idle.

  3. 03Pod

    provision-comfyui.sh

    It installs ComfyUI, custom nodes and model sets in an order that keeps torch and CUDA consistent.

  4. 04Pod

    launch-sharded.sh

    It starts one ComfyUI per GPU and splits a batch across them.

  5. 05Pod

    hold-busy.sh

    It keeps the pod awake while a long job that is not ComfyUI runs, and lets go when the job ends.

  6. 06Your machine

    sync-outputs.sh

    It pulls results home while a batch runs, checks every file, and tells the watchdog which folders are safe.

  7. 07Your machine

    check-gpu-load.sh

    It fails when one GPU samples much slower than the others, which usually means a model did not fit.

  8. 08Either

    comfy_client.py

    A small client that drives a local ComfyUI, a pod’s ComfyUI or Comfy Cloud with the same calls.

  9. 09Your machine

    catalog.py

    It lists current open models by task and re-checks the catalogue against Hugging Face.

From the batch in section 3.

5

Choosing a GPU

You pay for GPU-hours, so eight GPUs cost the same as one for the same work and finish sooner.

ConfigurationPer hourStockWork per dollar
8× A4048 GB each$3.52HighBest of the four
4× L40S48 GB each$3.96Medium80% of the best
4× RTX PRO 600096 GB each$7.96Medium55%, and the fastest
2× H10080 GB each$5.98High51%

An image from the batch, and depth and normal maps of the tram street from section 3. A depth pass takes seconds; any GPU that fits the model will do.

Fig. 5 These are configurations for Wan 2.2 image-to-video at 480p, which needs 48 GB. Prices and stock are from mid-2026; pod_ctl.py availability shows today's. Speech jobs ran comfortably on one 24 GB L4 at $0.39 an hour.

The same batch on managed services

  • RunPod, 8× A40$2–4
  • fal or Replicate~$17
  • RunComfy, A100~$23
  • Comfy.ICU, L40S~$53

Fig. 6 This is the estimated cost of one 554-clip video batch, about 4.6 GPU-hours. fal and Replicate endpoints cannot run a custom ComfyUI graph, and Comfy.ICU does not allow installing custom nodes.

6

Model catalogue

The catalogue lists 52 open models across 12 tasks, with the exact files ComfyUI loads. It was checked against Hugging Face on 23 October 2026, and catalog.py --verify checks it again.

Open licence allows commercial useTerms commercial use has conditionsNC non-commercial onlyGB is the VRAM it needs

Text to image5

An image made in the batch
  • FLUX 3 Image Klein16 GBTerms
  • Qwen-Image 2.120 GBNC
  • Krea 220 GBTerms
  • Z-Image Turbo16 GBOpen
  • MOSS-Image16 GBOpen

Image editing4

An edit of the teapot
  • Bria Fibo 2.016 GBNC
  • Qwen-Image 2.120 GBNC
  • Qwen-Image-Edit 251124 GBOpen
  • FLUX.2 [klein] 4B12 GBOpen

Text to video4

  • MiniMax H348 GBTerms
  • LTX-2.532 GBTerms
  • Wan 2.2 T2V A14B24 GBOpen
  • HunyuanVideo 1.516 GBTerms

Image to video3

A frame of a clip made from an image
  • MiniMax H3 I2V / FLF2V / continuation48 GBTerms
  • LTX-2.5 I2V / FLF2V / DFR32 GBTerms
  • Wan 2.2 I2V A14B24 GBOpen

Video to video5

  • Wan Animate 224 GBOpen
  • SCAIL-224 GBOpen
  • LTX-2.3 22B + IC-LoRAs32 GBTerms
  • Wan 2.2 VACE-Fun A14B24 GBOpen
  • Netflix VOID32 GBOpen

Lip-sync and avatars5

  • InfiniteTalk24 GBOpen
  • LTX-2.3 ID-LoRA TalkVid32 GBTerms
  • Wan 2.2 S2V 14B24 GBOpen
  • HuMo 17B24 GBOpen
  • LatentSync 1.612 GBTerms

Upscaling4

  • SeedVR2 3B/7B16 GBOpen
  • NVIDIA PiD16 GBNC
  • Real-ESRGAN x4plus4 GBOpen
  • RIFE v4.25 heavy / FILM frame interpolation4 GBOpen

3D4

A mesh made from an image
  • Pixal3D16 GBOpen
  • TRELLIS.2 4B16 GBOpen
  • TripoSplat8 GBOpen
  • Hunyuan3D 2.112 GBTerms

Speech4

  • Qwen3-TTS 12Hz 1.7B8 GBOpen
  • VoxCPM28 GBOpen
  • Resemble Chatterbox6 GBOpen
  • Ming 3.0 TTSOpen

Music4

  • MiniMax Music 316 GBTerms
  • ACE-Step 1.5 XL16 GBOpen
  • Stable Audio 312 GBTerms
  • YuE2 3B8 GBNC

Sound effects5

  • LTX-2.3 Foley V2A LoRA32 GBTerms
  • HunyuanVideo-Foley12 GBTerms
  • MMAudio large 44k v26 GBNC
  • Stable Audio 3 small-sfx6 GBTerms
  • Xiaomi ControlFoleyNC

Utilities5

A depth map
  • SAM 3.14 GBTerms
  • Depth Anything 34 GBOpen
  • BiRefNet4 GBOpen
  • SDPose wholebody + RT-DETR v4 detector4 GBOpen
  • MoGe 34 GBOpen

Each entry in docs/models.md says when to pick it, its licence terms and its ComfyUI workflow. Before a batch, run check_latest_models.py, because new models ship every month.

7

Traps

The repository lists 61 traps that cost time or money on a live pod, each with the rule that avoids it. Most are also an offline check that runs on every push.

  1. Trap2026-07-26

    Pod storage is scratch.

    A batch with no copy-back lost 200 to 400 frames and about $22 when the pod was reclaimed, so results now sync as they land.

  2. Trap2026-07-25

    Stopping a pod can strand it.

    A restart needs a free GPU on the same host, so the watchdog stops a pod only when its GPU type has high stock.

  3. Trap2026-07-26

    Only /workspace survives a restart.

    Every pip and apt install is gone after a stop and start, so provisioning runs its dependency step again.

  4. Trap2026-07-27

    A busy flag outlived its job.

    It held an idle H100 for three hours, so the lock is now a heartbeat that the watchdog ignores once it goes stale.

  5. Trap2026-07-26

    A leftover process halved a two-GPU render.

    One card took 494 seconds a frame instead of 127, so check-gpu-load.sh compares sampling speed across GPUs.

  6. Trap2026-10-23

    The watchdog could not act, then exited.

    Its calls were refused and the pod kept billing, so it now retries every poll and never exits while the pod can bill.

More frames from the music video.

All 61 traps are in docs/traps.md

8

Status and limits

Status

  • The full run was last tested live on 15 November 2026: setup and 40 jobs across five graphs on one L40S, in 1.9 hours, for $2.03.
  • On 23 October 2026 the watchdog terminated an idle L4 pod by itself, about a minute after it went idle.
  • On 20 November 2026 a background-removal job ran on Comfy Cloud through the batch harness in 5 seconds.
  • The offline checks run on Python 3.9 and 3.12 in CI, and need no network, GPU or API key.

Limits

  • Pods are rented on RunPod only. Comfy Cloud has no TRELLIS.2 weights, so 3D runs on a pod.
  • This rents real hardware with real money. You are responsible for your RunPod bill.
  • The watchdog reads the queue of the first ComfyUI only. The launcher keeps the pod busy while any GPU still has work.
  • docs/open-questions.md lists what has not been proven yet.