Model reference · open weights

agate-003

Image Logolabs Text→image 1 build Open weights 713 dl/mo

agate-003 is an open-weight image model from Logolabs. agate-preview-003 (BF16) weighs 777 MB; the smallest configuration that runs it is RTX 3060 12 GB.

For self-hosting, compare this build's requirements below with the GPU you plan to rent.

  • Agate Preview 003 is a text-to-image model by Logolabs that generates 512 by 512 pixel images from English prompts.
  • It contains 261 million parameters and is released under the MIT license.
  • The model is designed for glyph and symbol generation and runs in Python, ComfyUI, or a browser WebGPU demo.

Summary of the Logolabs/agate-preview-003 model card, 2026-10-07

What it is

Released byLogolabs
Released2026-09-29
VRAM777 MB for the weights

What it runs on

Memory and cards for agate-preview-003 (BF16)

777 MBweights, file size
5.0 GBworking memory, one 1024² image
537 MBruntime overhead
CardOne imageMemory
RTX 3060 12 GBfits11.6 GB
RTX 4060 Ti 16 GBfits15.4 GB
RTX 3090 24 GBfits23.4 GB
RTX 4090 24 GBfits23.4 GB
RTX 5090 32 GBfits31.0 GB
L40S 48 GBfits44.0 GB
A100 80 GBfits78.2 GB
H100 80 GBfits78.1 GB
RTX PRO 6000 Blackwell 96 GBfits93.8 GB
DGX Spark (GB10) 128 GB unifiedfits107 GB
H200 141 GBfits138 GB
B200 180 GBfits176 GB

From the model card

What Logolabs says about agate-003

Read the model card

Agate Preview 003 renders at 512 × 512. It is the first Agate to score above Stable Diffusion 1.5 on Qwen-Image-Bench: 32.6 against SD 1.5's 29.1 and Preview 002's 28.9, on all 1,000 prompts, with 261M parameters. On GenEval (official scorer) it scores 0.554, level with Preview 001 (0.550) and below Preview 002 (0.577).

It is Agate's 256 px network made multi-resolution (additions that start as exact no-ops), trained at 256 and 512 px, then fine-tuned with perceptual losses. It runs in Python, in ComfyUI (0.4.0) and in the browser (WebGPU demo, the default version there).

Built by LogoLabs, which makes AI logo generation.

Why we built Agate: it is the result of an architecture study for glyph and symbol generation; see Why we built Agate below.

At a glance

WhatText-to-image, 512 × 512 (256 × 256 also supported), English prompts
Size261M parameters with TAESD, 309.8M with SD-VAE: 192.1M active generator + 68.1M text encoder + decoder
TrainingFrom Agate's 256 px run (step 121,440), 24,900 more steps at 256 + 512 px; 196.6M images seen in the whole lineage
Compute282.8 GH200-hours for the whole lineage from scratch (+22.5 for 512 px data preparation), 164.5 kWh, 4.94 kg CO₂e; GPU energy measured with perun, see About these energy figures
Qwen-Image-Bench (1,000 prompts)32.6. SD 1.5 29.1, Preview 002 28.9, Preview 001 28.2
GenEval (official)0.554. Preview 002 0.577, 001 0.550; SDXL 0.55, SD 1.5 0.43 (published)
Speed2.9 s per 512 px image on an RTX 4060 (50 steps, bf16, CUDA graphs; 4.5 s without), 5.7 GB peak VRAM
FrontendsPython, ComfyUI nodes 0.4.0, WebGPU demo (~14 s per 512 px image in the browser on an RTX 4060)
LicenceMIT, for code and weights
StatusResearch preview

What changed from 002

  • 512 px. The thinker still plans on a 16 × 16 grid; it reads the 64 × 64 latent through its original read of the stride-2 subsample plus a new conv branch. The renderer runs at 64 × 64 with raw coordinates and an explicit resolution signal. The sampler uses the SD3 resolution shift 2 at 512 px.
  • Prompt pipeline. Prompts are normalised (SHOUTED or Title Cased prompts lower-cased outside quotes, number words made canonical); "without X" / "no X" move to the negative prompt; text in double quotes is also spelled out letter by letter; a count code marks object counts. Training used the same pipeline, and AgatePipeline applies it.
  • Perceptual fine-tune. The last run trained with a saliency-weighted flow loss plus 0.1 LPIPS and 0.01 P-DINO on the model's one-step prediction.

Put the loss where it matters

Plain flow loss averages the error over every latent cell, so a face, a word or the subject barely counts, and squared error rewards soft, averaged detail. 003's last run (mr512_perc1) kept the flow loss but weighted each cell by its UNISAL saliency, w = 1 + 0.1·t·(q − 1) (q: the cell's saliency relative to the image mean, capped at 5×; the maps are computed once and cached). It also added LPIPS (× 0.1, local texture) and DINOv2 patch features (P-DINO, × 0.01, structure) on the VAE-decoded one-step estimate, for t > 0.3 only, after the PixelGen recipe. What we know: the QIB gain over 002 is not attributed between 512 px and these losses, and a later fine-tune of 003 without them worsened LPIPS by 1.8% and P-DINO by 2.0% against the base, so fine-tunes of 003 should keep this objective.

Quick start

pip install torch transformers diffusers safetensors huggingface_hub pillow invisible-watermark
import sys
from huggingface_hub import snapshot_download

path = snapshot_download("Logolabs/agate-preview-003")
sys.path.insert(0, path)
import agate
from agate import AgatePipeline

pipe = AgatePipeline.from_pretrained(path, device="cuda")      # "cpu" works too: ~100 s per 512 px image
image = pipe('a shop sign that says "OPEN", three red apples on a table, no people', seed=0)[0]
agate.save(image, "open.png")            # keeps the AI-generated metadata in the PNG
ArgumentDefaultWhat it does
seed0Same seed, same image.
steps50Euler steps from noise to image.
cfg3.0Classifier-free guidance against the negative prompt.
resolution512512 (shift 2) or 256 (no shift).
negative_prompt""Combined with the negatives cut from the prompt ("no people" above).
normalize / spellTrueThe prompt normaliser (with negatives and count code) and the spelled-out quoted text. Both were on in training.
num_images1Images per call, one batch.
watermark / metadataTrueInvisible watermark and AI-generated metadata on every image (see marking).
record_promptFalseAlso store the prompt and seed in the image metadata.
fast_vae (from_pretrained)FalseDecode with TAESD instead of the full SD-VAE.
cuda_graphs (from_pretrained)TrueRecord each denoising step once as a CUDA graph and replay it (same output, ~1.6× faster on an RTX 4060).

pipe.prepare(prompt) shows the prompt as the text encoder sees it and the negative prompt it produced. Preview 003 has no autoguidance option.

Results

All scores were measured by us with the same seeds, sampler and scorer for every model. Preview 003 generates at 512 px, SD 1.5 at 512 px, Previews 001 and 002 at 256 px; every scorer saw 512 × 512.

Qwen-Image-Bench

| Model | Native | Total | Quality | Aesthetics | Alignment | Real-world Fidelity | Creative Generation | |---|---|---|---|---|---|---

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

Running it yourself

Run it on a rented GPU

Rent a machine by the hour. How to run this model is on its model card.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms