How fast is chat-triggered FLUX image generation on a 16 GB GPU?

50 s wall per run on the fast profile (1280×720, 20 steps — three identical logged runs), 66–68 s warm on the full profile (1920×1080, 28 steps, four runs, three of them face-locked), 112 s for one full-resolution art render, and 330–379 s for the two runs that open a session — the cold model load, not the render. Total corpus: 10 logged runs, 14 finished images on disk.

How does the image get back into the chat group?

The factory script posts it itself. When the render finishes it calls the messaging bot API directly and sends the photo to the workshop's group chat — the AI agent that received your command never touches the delivery. The agent's job ends at launching the script with the right flags.

How does face-lock generation work in this workshop?

Send a photo with a clear face to the chat; it lands in an inbound folder, and the next generation passes it to PuLID (flux v0.9.1 weights) with identity weight 0.65 on the fast profile or 0.8 on full. The prompt then describes what the person is doing, not what they look like — the reference image owns the face.

Why rewrite prompts before generating video base plates?

Image-to-video models smear fast motion. The script's i2v mode strips quality-word filler ('8k', 'masterpiece') and rewrites dynamic verbs to static tension — 'running fast' becomes 'standing alert, coiled energy' — so the base image holds a pose the video model can animate from.

How Fast Does a Chat Command Become a Finished AI Image? Inside the One-Man FLUX Workshop

Episode 1 of One Man One Legion — the series map lives there. This is the image workshop from that map, measured.

Type a phrase in a chat group — in Chinese, any of the trigger words for “draw”, “generate an image”, or “face-lock” — and the legion’s image workshop takes over. An agent parses the request, launches a factory script with the right flags, and a single RTX A4000 16 GB renders it through ComfyUI’s HTTP API (no web UI involved). When the file lands, the script itself posts the photo back to the group through the messaging bot API. The measured cost across ten logged runs: 50 seconds on the fast profile, 66–112 s warm on the full profile, and 330–379 s when the workshop is cold. Fourteen finished images sit on disk. This episode documents the whole path, from the command’s arrival to the photo’s delivery, with the run table below as its evidence.

The command path: agent launches, script delivers

The division of labor is the interesting part. The agent that hears the command does three things only: pick the profile, collect an optional face reference (the latest photo in the inbound folder), and launch flux_image_factory.py in the background — control returns in 0 s while the GPU works. Delivery is deliberately NOT the agent’s job: the script calls the bot API itself and the photo appears in the group without any agent involvement. Heavy work goes through a direct pipe; only judgment goes through the model chain.

Two profiles, pinned constants

The factory script ships a two-profile strategy matrix, because the workshop’s images serve two different masters — quick iteration, or full-resolution plates that later feed video:

Profile	Resolution	Steps	Guidance	PuLID weight	Logged as
Fast (i2v seed)	1280×720	20	3.5	0.65	“1280×720/20步/快”
Full (art)	1920×1080	28	5.5	0.80	“1920×1080/28步/满血”

CFG is pinned to 1.0 — a FLUX-specific constant the script’s author marked as an iron rule after experimentation. Face-lock runs pipe the reference photo through PuLID v0.9.1; the prompt then describes action, not appearance, because the reference image owns the face.

The ten runs, as logged

Every completed run writes a job log with the mode line, seed, and wall time. The full corpus:

#	Mode	Resolution / steps	Face-lock	Wall time
1	Fast	1280×720 / 20	—	50 s
2	Fast	1280×720 / 20	—	50 s
3	Fast	1280×720 / 20	—	50 s
4	Full, cold open	1920×1080 / 28	—	379 s
5	Full, cold open	1920×1080 / 28	—	330 s
6	Full, warm	1920×1080 / 28	—	68 s
7	Full, warm	1920×1080 / 28	yes	66 s
8	Full, warm	1920×1080 / 28	yes	66 s
9	Full, warm	1920×1080 / 28	yes	66 s
10	Full, art	1920×1080 / 28	—	112 s

Runs 4 and 5 opened their session cluster — the same settings then settle to 66 s (runs 7–9). That is the workshop’s real cost structure: the first image of the night costs ~6 minutes (the fp8 FLUX stack, ~11 GB of weights, loading into VRAM), every image after costs about a minute. Face-locking adds nothing measurable at this sample size: 66 s versus 68 s warm.

Craft that only shows up in the script

Two details worth stealing. The i2v mode rewrites prompts before rendering: it strips quality-word filler (“8k”, “masterpiece”, “hyperrealistic”) and converts dynamic verbs into static tension — “running fast” becomes “standing alert, coiled energy”, “diving” becomes “suspended mid-motion, controlled” — because image-to-video models smear fast motion, and a base plate that already implies motion animates poorly. And the model files are pinned by exact filename in the script (flux1-dev-fp8, clip_l, t5xxl_fp8, the ae VAE, pulid_flux v0.9.1), which is what makes a run reproducible two years later: same weights, same seeds, same seconds.

What we claim and what we don’t

Ten runs is a log corpus, not a benchmark: no throughput-under-load numbers, no quality scoring, and the 50 s fast-path runs share one prompt family. Cold-load times are session-opening observations (n=2), not a controlled cold-start benchmark. All timings are wall-clock from the workshop’s own logs, single GPU, queue-dependent.

Primary sources: the workshop’s job logs (10 files, mode line + seed + wall time each, 2026-08), the factory script’s profile matrix and prompt-rewrite rules as read from source, and 14 finished images on disk.

Measured 2026-08-27 from the 2026-08 log corpus. License: CC BY 4.0 — cite the source URL.

Episode 2 continues next-door in the video workshop — the InfiniteTalk dual-GPU dispatch already covers its measured deep end: Can You Run InfiniteTalk on Two Consumer GPUs?. Back to the series map.