The loop

This page is the whole system on one screen. Everything else in these docs is a closer look at one of these boxes.

   roster (designers × colorways × garments × templates)
      │
      ▼
   SelectionEngine ──► compose (gemini-2.5-flash) ──► render (Imagen 4 Ultra) ──► segment (SAM 3)
      ▲                     │ scene template LOCKED          │                        │
      │                     │ innovation axes rotate         ▼                        ▼
      │                     ▼                            ReviewHub ◄────── garment crops + hitmap
      │              negative prompt =                        │
      │              learned bans (short nouns)               ▼  Shawn grades
      │                                          ┌────────────┴────────────┐
      │                                          ▼                         ▼
      │                                   outlier/catalyst/on-brand   off-brand/ugly
      │                                          │                         │
      │                                          ▼                         ▼
      │                                   birth certificate           kill phrases / bans
      │                                   (seed for the Lab)          (fence future prompts)
      │                                          │                         │
      │                                          ▼                         │
      │                                   LAB: clone winners,              │
      │                                   blend bodies, push frontier      │
      │                                          │                         │
      └──────────────── notes + vocab ◄──────────┴─────────────────────────┘
                        (injected into every future compose)

Reading the diagram

Start at the top left. The roster is the curated pool of raw material: designers whose aesthetic the engine can reference, colorways it can dress models in, and garment bodies it can build outfits from. The SelectionEngine deals that material into a daily batch of outfit "manifests" — one designer, one colorway, three complete model outfits per look — with diversity guards so the same combinations don't repeat.

Each manifest goes to the compose step, where a language model writes the actual image prompt. Two forces shape that prompt in opposite directions, and that tension is the heart of the system: the scene template is locked (same backdrop, same spacing, same framing on every image), while the garment descriptions innovate (new construction language on every look). The result renders on a consistent stage with fresh design on it.

After rendering, every garment in the image is segmented so ReviewHub can attribute a grade to one garment on one model — not just to a whole image.

Then Shawn grades, and the loop closes along two paths. Wins (outlier, catalyst, on-brand) become birth certificates — complete records of what worked — which feed the Lab, the arm of the system that clones and evolves proven designs. Losses (off-brand, ugly) become kill phrases — banned language that is pushed into the negative prompt of every future render. And all grades become notes that are injected into future compositions for the same designer, colorway, or garment.

Two arms, two budgets

The system spends its daily budget on two different jobs:

• Roster generation (batch looks per day, default 30) explores the curated roster with innovation on every look. This is where new design comes from.
• The Lab (lab_batch experiments per day, default 12) exploits what already won: it clones outliers, blends winning garments into new hybrids, and pushes frontier experiments. This is where proven design evolves.

The two budgets are independent — experiments never eat roster volume, and parking the Lab (lab_batch: 0) doesn't slow daily generation.

Nothing learns invisibly

Every piece of learned knowledge is a file you can read (the memfs notes) or a row you can query (Postgres). The Strategist's Learning tab is a browser over exactly the same files the engine reads when it composes. If the engine knows something, you can see it.