THE CREATION FACTORY

Ad-hoc generation is a trap that disguises itself as productivity. You fire off an image, it looks good, you use it — and three weeks later you can't reproduce it. The model has been swapped. The seed was never recorded. The prompt was tweaked by hand and not written down. The result exists; the recipe doesn't.

Scale that pattern to a studio running dozens of generations a week across multiple checkpoints and LoRA stacks, and you've built a black box that produces output you can't audit, can't replay, and can't improve systematically. Quality drifts because there's no signal to track it against. "Automated" generation usually means "unsupervised" — the machine runs, nobody grades the output, and taste erodes while throughput climbs.

The studio needed something different: a pipeline where every asset carries a receipt, where a human grades every batch before anything enters the library, and where those grades feed back into the system to teach it what good looks like.

The Creation Factory is a five-stage event-driven pipeline. A trigger arrives — a chat command or a scheduler event — and it pulls a recipe from a registry. The recipe is the contract: model, checkpoint, sampler settings, prompt template, seed policy. Nothing ad-hoc reaches the GPU. The worker dispatches to a local GPU via the ComfyUI API, and when the job completes, every output is written to a provenance store with its full lineage: recipe version, model name, inference parameters, timestamp, and the job ID from the GPU worker. The asset and its receipt are inseparable.

Generated assets surface in a morning gallery for one-tap human grading. The operator sees the output, marks it accept or reject, and moves on in seconds. Those grades are not discarded — they flow back into the taste model, nudging weights toward what the principal actually approves. The loop closes: trigger → GPU → store → gallery → grade → model. No grade is anonymous. No good output is a mystery that can't be reproduced.

Dependency-free runner. The pipeline runner is pure Python standard library. No framework, no package manager, no virtualenv required. This was a deliberate constraint: a runner with zero external dependencies survives model migrations, environment churn, and OS updates without a single pip install in a runbook. Portability is a reliability feature.

Recipe-as-contract design. A recipe is a versioned, named data structure in a registry — not a freeform prompt attached to a button. When a recipe changes, it gets a new version. Old outputs point to the recipe version that produced them. This means the provenance store never has an orphaned asset: you can always answer "what exact configuration produced this?" and "has that configuration changed since?"

Spine proven first. Before any automation was wired up, the full five-stage path was run manually end to end. First live run: 2 images in 28 seconds, 2/2 successful, provenance records written. Only once the spine produced a verified receipt did work begin on the surrounding automation. Infrastructure that hasn't produced a real artifact hasn't proven anything.

"Built ≠ armed" as governance. The pipeline ships with no cron job, no systemd timer, no autonomous trigger wired by default. This is intentional and documented as a feature, not a gap. Before autonomous operation begins, the system must prove a false-positive record: a human reviews its gallery output and confirms quality holds across a real sample. Only then does the principal grant the scoped arming — and only for the specific capability and cadence reviewed. A pipeline that can run unsupervised before it has proven it deserves to isn't an automation; it's a liability. The arming discipline is the governance story, and it's told proudly.

The spine is live and proven: trigger arrives, recipe resolves, GPU renders, provenance is written, gallery populates, grade flows back. First run produced 2/2 images in 28 seconds end-to-end. The studio now has a reproducible answer to "how was this made?" for every asset in the library — something that simply didn't exist before.

Throughput at scale and cost-per-asset are not yet measured — the pipeline is operating at early cadence while a false-positive record accumulates. That number will be real when it's earned. What is measured: the provenance store has zero orphaned assets, and no output has entered the library without a human grade.

The taste model is the long game. Each grading session is training data. The more the principal grades, the tighter the autonomous picks. "Automated" without accountability is just noise at scale; this system was built so that the machine's taste and the principal's taste converge — measurably, incrementally, from day one.