# I let a local agent run MiniMax H3 overnight on the same GPU as its LLM, without OOM. Here's the tool that makes them take turns — retained record

> Retained reddit record from reddit:comfyui.

Canonical: https://highsignal.app/data/records/3383772a85c9ae05

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:comfyui)  published 2026-10-18 23:05 ingested 2026-10-19 02:42

[original source ↗](https://www.reddit.com/r/comfyui/comments/1x9h40v/i_let_a_local_agent_run_minimax_h3_overnight_on/)

## retained text



```
**Want your local LLM agent to drive ComfyUI on the same consumer graphics card?** Without coordination, the first video render lands on top of the loaded LLM, and something runs out of memory. Boom, OOM.

I built **vhotseat** to fix that. It makes the LLM server and ComfyUI take turns on VRAM *and* RAM:

* When the agent queues a render, the LLM is unloaded.
* When the agent asks the LLM its next question, ComfyUI's models are freed.
* Neither ever loads on top of the other.
* Running work is never interrupted. That covers an answer the LLM is writing and a render in progress.

**Setup I run it on:** RTX 5070 Ti 16 GB, 64 GB RAM, Linux.

* **LLM:** Strata serving Qwen3.8-Flash-Next IQ3\_XXS (128K context). It takes \~14.7 GB of VRAM and \~44 GB of RAM.
* **Agent:** pi.
* **ComfyUI:** MiniMax H3 int8 (`fl2va` / `ref2va`) with the turbo LoRA. A render needs \~14 GB of VRAM.

With this setup, the agent has run long video jobs unattended, for several rounds of render → review → render, overnight.

# Demo

I gave the agent one prompt:

>Make two 3-second anime-style clips of a cat on a windowsill with MiniMax H3, then tell which one looks better. Continue working on a clip of the cat jump from windowsill to catch a bird. Concat this two clips into a single video file.

It did the rest on its own, in two render rounds:

1. **Round 1:** two takes of the windowsill shot, in one batch (3 min 41 s). The LLM was unloaded for the batch.
2. **Review:** the LLM came back. The agent made a contact sheet of both takes, looked at it with Flash-Next's vision, and picked take A ("B substitutes a butterfly for the bird").
3. **Round 2:** it used the last frame of take A as the first frame of the jump, and rendered two takes (5 min 38 s).
4. **Review and finish:** the LLM came back again. The agent picked the take with a real leap and joined the two clips with ffmpeg.

That's four GPU handovers, and no OOM.

The dashboard (`vhotseat web`) for that session shows the handovers. VRAM and RAM switch from Strata (blue) to ComfyUI (orange) and back.

# How it works on the ComfyUI side

* **A small custom node (the guard)** runs before every job, whoever queued it: the agent, a script, or you in the web UI. It waits for any answer the LLM is writing, then unloads the LLM. If that can't happen in 5 minutes, the job fails visibly instead of running into an OOM.
* **Before the LLM loads,** vhotseat frees ComfyUI's models. If ComfyUI's leftover RAM is what's in the way (it can hold 6-15 GB after a video render), vhotseat restarts it, but only when its queue is empty.
* **While ComfyUI has anything queued or running,** the LLM won't load. The agent's harness just retries.
* `comfy-render` is a small CLI the agent uses to run a batch of workflows in one call. A batch costs two handovers instead of two per job.

You don't change your workflows. The LLM side uses Strata's pre-load hook. Other LLM servers (Ollama, llama-server) work through a small proxy, and there's a guide for that.

The same goes for any other GPU job (a training run, a TTS server, a script): wrap it with `vhotseat hold NAME -- COMMAND`, and it takes its turn the same way.

# Try it

Free, open source (MIT), no signup. Linux and NVIDIA for now; Windows is planned.

    uv tool install vhotseat      # or: pipx install vhotseat

GitHub: [https://github.com/wandermyz/vhotseat](https://github.com/wandermyz/vhotseat)

There's a step-by-step quick start for this exact setup, written so a coding agent can follow it. Or give your coding agent this:

>Set up vhotseat so my local LLM agent can drive ComfyUI on this GPU without running out of memory. Follow [https://github.com/wandermyz/vhotseat/blob/main/docs/guides/quickstart-strata-pi-comfyui.md](https://github.com/wandermyz/vhotseat/blob/main/docs/guides/quickstart-strata-pi-comfyui.md), adapting it to the servers and paths on this machine, and run each step's check before going on.

**Honest limits:**

* Each handover costs time. Loading the LLM back takes \~30 s on my machine, and it reads the conversation again afterwards. Batching renders is what keeps this bearable.
* I've only tested one card (16 GB) and one ComfyUI model family (H3).
* After a ComfyUI update, the guard node is the part to check. There's a doc for that.

I'm curious how others run an LLM and ComfyUI on one card. Do you unload by hand, use two GPUs, or just keep the LLM small? And if you try this on another card or model, I'd love to hear how it goes.
```



document fetched 2026-10-19 00:37 · canonical https://reddit.com/r/comfyui/comments/1x9h40v/i_let_a_local_agent_run_minimax_h3_overnight_on
