Skip to content
The Lab

Assets we generated, and how.

Work from our own generation pipelines, running on studio hardware. The method is on show alongside the output, because the method is the part worth hiring.

How we work with it

We do not hand a brief to a model and ship what comes back. The thinking is ours: what the thing needs to be, what good looks like, and which of forty outputs is the one worth keeping.

AI is an assistant here, not a substitute for the work. It is fast, tireless and confidently wrong, and it needs managing the way anything fast, tireless and confidently wrong needs managing. So we plan with it, direct it, correct it, and throw most of what it makes away.

The iteration set on this page is what that actually looks like — the same ruin three times, because the first two were not right. Sixty-eight images kept out of a far larger run. What ships is what we chose, not what a model happened to produce.

Used this way it makes the work faster without making it thinner. The judgement is still the job; the assistant is what removes the hours around it.

Exhibit 01

Local language models

These run on studio hardware. Client material never leaves the building, and no third party is metering the work while we iterate — so a draft gets redone because it should be, not because a usage line allows it. Hosted models are in daily use too, where they are the better tool; what decides it is the job in front of us, not a policy.

Input
Unstructured text, screenshots, documents
Method
  1. input
  2. local model
  3. schema check
  4. structured output
Models
  • Qwen3-VL 8B
  • Qwen3.5-9B
  • gpt-oss-20b
  • Gemma 4 12B QAT
  • Gemma 4 E4B QAT

  • Qwen3-VL 8B

    8.8B

    A vision-language model — it reads images the way other models read text.

    Good at
    • Reading a screenshot and writing the HTML and CSS for it
    • OCR across 32 languages, including low light, blur and skew
    • Understanding a document's structure, not just its words

    Here we use it for Turning a design reference or a screenshot into a first pass of markup — and reading dense material. Give it a page heavy with text and it comes back with what the content actually says, rather than a paraphrase of the first paragraph.

    • LM Studio

  • Qwen3.5-9B

    9B

    A small model that reasons like a much larger one — it outscores a 120-billion-parameter model on graduate-level reasoning.

    Good at
    • Structured reasoning over long inputs — 262k tokens of context
    • Working across 201 languages
    • Pulling clean data out of messy text

    Here we use it for The day-to-day model — writing code, thinking a problem through in plain conversation, and wiring integrations together.

    • LM Studio
    • Apache 2.0

  • gpt-oss-20b

    21B total, 3.6B active

    OpenAI's open-weight model. Mixture-of-experts, so it runs at the speed of a small model while reasoning like a bigger one.

    Good at
    • Tool use and function calling — the agent-shaped work
    • Reasoning effort you can dial up or down per task
    • Showing its full chain of thought, so a wrong answer is debuggable

    Here we use it for Coding, specifically. The most capable of the set at writing real code, and it does it without anything leaving the machine.

    • Ollama
    • Apache 2.0

  • Gemma 4 12B QAT

    12B

    Google's multimodal model, trained with quantization built in rather than compressed afterwards — so it keeps close to full quality at roughly a quarter of the memory.

    Good at
    • Running well on hardware that should not really fit it
    • Text and image in, 256k context
    • Over 140 languages

    Here we use it for A capable coder, and better than most of its size at planning a piece of work before any code exists. The one reached for most often.

    • LM Studio
    • Ollama

  • Gemma 4 E4B QAT

    Effective 4B

    The small one. Same quantization-aware training as its larger sibling, at a size that stays responsive on ordinary hardware.

    Good at
    • Holding a conversation without a wait between replies
    • Running comfortably where a 12B model would not
    • Text and image in, like the rest of the Gemma 4 family

    Here we use it for A genuinely good lightweight chatbot — small enough to stay quick, capable enough to be worth running rather than tolerated.

    • Ollama
Before
hey - got your details off a mate. we run a small disability support
service up in newcastle, about 18 staff. need a proper website, the
current one is wix and honestly looks it. bigger thing though is staff
training, we're doing inductions out of a folder and it's a mess.
budget probably 15-20k but could stretch if the training side works
out. no massive rush but ideally sorted before the new financial year.
easiest to get me on the mobile in the arvo, mornings are chaos here
After
{
  "intent": "new_project",
  "organisation": {
    "sector":   "disability_support",
    "location": "Newcastle, NSW",
    "staff":    18
  },
  "services":  ["company-website", "lms"],
  "priority":  "lms",
  "replacing": "Wix",
  "budget":    { "min": 15000, "max": 20000, "flexible": true },
  "deadline":  { "date": "2026-06-30", "firmness": "preferred" },
  "contact":   { "channel": "phone", "window": "afternoon" },
  "next_action": "call"
}
Retrieval
nomic-embed-text v1.5 and qwen3-embedding, so a body of documents can be searched by meaning rather than by keyword. Also local.
The line-up
Not fixed. Document work ran on Nemotron until the quantization-aware Gemma 4 releases did the same job on less hardware. Running the models ourselves means changing one is a download rather than a contract.
Hosted models
Not everything runs here, and it was never meant to. Claude is in daily use across our own work — Haiku, Sonnet, Opus and Fable each suit a different size of task, and knowing which to reach for is most of the skill — with Gemini as the second option, for work that does not need Claude. Local and hosted are two tools rather than two camps: what settles it is whether the material can leave the building, and which model actually does the job better.
Exhibit 02

Image and video generation

Every image on this page came out of a pipeline we run on studio hardware — no third-party subscription metering each render, and no external terms deciding what a client is allowed to generate. The models below are the ones actually installed and used.

Input
A written brief, a reference image, or a still to animate
Method
  1. brief
  2. generate
  3. image-to-image
  4. upscale
  5. select
Models
  • Flux.1 Dev FP8
  • SDXL
  • WAN 2.1 I2V 14B
  • RealESRGAN

  • Flux.1 Dev FP8

    12B, FP8

    The main image model. FP8 quantized so a 12-billion-parameter model fits on a single consumer card without losing the thing that makes it worth using — it follows a written brief closely.

    Good at
    • Holding to a detailed prompt rather than drifting toward a house style
    • Environments, props and product imagery
    • Legible text inside an image, which most models still cannot do

    Here we use it for Environments, items and product shots — the bulk of what The Lab shows.

    • ComfyUI

  • SDXL — Animagine XL, Pony Diffusion V6

    6.9 GB each

    Illustration-trained checkpoints on the SDXL architecture, kept alongside Flux because they draw people in a way a photoreal model does not.

    Good at
    • Character and figure work in an illustrated register
    • Consistent style across a cast rather than one lucky render
    • Responding to pose and composition control

    Here we use it for Character art, where the look wanted is drawn rather than photographed.

    • ComfyUI

  • WAN 2.1 I2V 14B

    14B, Q5_K_M

    Image to video. Takes a single still and animates it, rather than generating motion from a text prompt alone.

    Good at
    • Animating an image that has already been approved
    • Short loops — ten seconds and under
    • Keeping the subject recognisable from frame to frame

    Here we use it for Turning a finished still into a short loop. Both clips below were made this way.

    • ComfyUI

  • Style LoRAs

    6 installed

    Small adapters that steer a base model toward one look. These are community-trained and picked to match the model they sit on — four vector-style adapters, an icon kit, and a general vector set, across Flux and SDXL.

    Good at
    • Holding one visual style across an entire asset set
    • Icon and vector work, where consistency matters more than variety
    • Getting a house look without writing it into every prompt

    Here we use it for Consistency. A set of icons that reads as a set, rather than forty images that each went their own way.

    • ComfyUI

  • ControlNet · RealESRGAN

    OpenPose, Union Promax, ×4

    The control and finishing end of the pipeline. ControlNet constrains what a model is free to change — pose, composition, structure. RealESRGAN takes the chosen result up to print resolution.

    Good at
    • Fixing a pose or a layout while letting the model decide the rest
    • Re-generating a scene without losing its composition
    • Taking a 1024px render to 4K cleanly

    Here we use it for Direction rather than luck, and the 4K cut-outs at the end of it.

    • ComfyUI
Why local
A hosted service charges per render and sets rules about what may be generated. Running it here means iteration is not rationed, client material stays off someone else's servers, and a set can be extended a year later with the same weights and the same workflow. The running cost is ours to carry and is priced into the work — not a meter that climbs with every attempt you ask for.
Exhibit 03

Stashly — product imagery

Stashly is a house inventory app — somewhere to know what you own and where you put it. It needed product imagery and has no physical product to photograph, so the jars were generated rather than pulled from a stock library.

Input
Product description
Method
  1. brief
  2. generate
  3. select
Models
  • Flux.1 Dev FP8
Exhibit 04

Toll — game art

A group of freelancers wanted to build the game they kept not finding — elements they liked from a dozen others, pulled into one with its own story and its own characters. What they did not have was an artist, or a way to turn mechanics into working code. Both were built here: every asset is generated, and every system behind them is written. Character art is currently moving from one static image each to six or seven.

See the project in the portfolioPlay Toll (opens in a new tab)
Input
Written scene and item briefs
Method
  1. brief
  2. generate
  3. image-to-image
  4. refine
  5. select
Models
  • Flux.1 Dev FP8
The hard part
Not the art. Making character kits interact with one another and with the AI is where the work actually is — a single component such as the battle arena or the deck runs to a thousand lines and beyond.
On the selection
Sixty-eight images kept from a much larger run. The iteration set — the same ruin across three passes — is the honest version of what that process looks like.

This page is the generation work. The interface side — the components we build with — is on The Workbench.

Want this pointed at your project?

Start a Project