Agate Preview 003

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

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

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

The gain over Preview 002 is mostly judged quality (26.4 → 38.2), where 002's 256 px images are upscaled for the judge and 003's are not. We have not measured where the gain comes from. 003 differs from 002 both in resolution and in its perceptual fine-tune, and we did not score a 512 px model trained without the perceptual losses, so the 28.9 → 32.6 gain is not attributed between the two.

Self-evaluated. The leaderboard rows are as published by the benchmark's authors. The Agate and SD 1.5 rows are our own runs of the official Q-Judger on all 1,000 prompts (one image per prompt, shown at 512 × 512); we have not submitted them, and the leaderboard's own protocol may differ. Read the comparison as indicative.

GenEval (official scorer)

The official GenEval pipeline on all 553 prompts, four images per prompt:

At 512 px, 003 places two objects better than 002 (0.672 vs 0.629) but trails it on every other category, most on colour binding (0.410 vs 0.455), position (0.225 vs 0.273) and counting. Our earlier 512 px runs showed the same attribute-binding loss on the larger canvas.

Internal image metrics

COCO-5k with our own eval suite: FID 34.40 and FD-DINOv2 434 (002: 34.01 / 413). Flat: these measure closeness to COCO photographs, which no Agate model trained on.

256 px against 512 px

Manual test battery

60 prompts in 16 categories, two seeds each, at 512 px with the released settings, shown uncurated.

How Agate works

The thinker/renderer split is 001's (the figure and its numbers are from Preview 001's card). Preview 003 keeps the thinker's 16 × 16 plan and changes how it reads the canvas and how the renderer runs at 512 px, as shown above.

Training

mr512_long1 crashed at step 13,590 on a tokenizer thread race of ours (fixed); mr512_long2 resumed from its step 12,000 checkpoint. The perceptual losses follow PixelGen: VGG LPIPS and DINOv2-B patch features on the decoded one-step prediction, only for t > 0.3, with UNISAL saliency weighting the flow loss. The perceptual target is the VAE decode of the clean latent. No flow-only or perceptual-only control arm was run.

The logged loss is not comparable across the start of mr512_perc1: from there it includes the saliency weighting, LPIPS and P-DINO, so its level and the jump at that point reflect the change of objective (and a re-warmed learning rate), not a change in quality.

Training data and safety

Preview 003 was trained on the same data as Preview 001: FLUX-Reason-6M, a curated, fully synthetic dataset of compositional and reasoning prompts. Its authors document quality filtering but no NSFW filter, and we have not audited all 5.65M images.

Red-teaming (measured for Preview 003, 2026-09-29). Four seeds per prompt, 50 steps, each output scored by an open NSFW image classifier (Falconsai/nsfw_image_detection, flagged at P(nsfw) >= 0.5). By design no prompt sexualised or undressed a minor: minors were probed only with benign prompts.

• Minors: no unprompted nudity found (highest classifier score 0.017).
• Adults: Preview 003 renders adult nudity (bare torsos, breasts, bodies) when asked, and in roughly one in ten ordinary prompts about people without being asked, as in the test battery below (cell 25, blurred). In our review of the flagged outputs it did not render genitals.
• The classifier measures nudity, not how explicit an image is; these are our measurements, not a guarantee.

Use a negative prompt (for example "nudity, topless") or an output filter where it matters.

Agate ships without a safety classifier; public-facing deployments should add one. Using Agate, or any model derived from it, to depict minors sexually, to create non-consensual intimate imagery, or to depict real people deceptively is prohibited and, in most jurisdictions, illegal. Report any such output to LogoLabs through logolabs.org.

AI-generated content marking

Every image the pipeline returns is marked as AI-generated in two ways (on by default; watermark=False and metadata=False switch them off):

• An invisible watermark in the pixels (invisible-watermark, method dwtDctSvd) carrying the fixed payload AGATE003. In our tests it survived a PNG round trip, a JPEG re-save at quality 90 and a 0.75× resize, and was absent from images Agate did not generate (40 dB PSNR against the unmarked image). It is not recoverable on about 1–2% of outputs, mostly flat logos on a pure white background, where clipping at white erases the embedded bits (measured on the 120-image test battery of each release, fresh images: 1–2 misses per 120). The metadata still marks those images.
• Provenance metadata in img.info: ai_generated: true, generator: Agate Preview 003 (LogoLabs), model: Logolabs/agate-preview-003. Save with agate.save(img, "out.png") to keep it as PNG text chunks. The prompt and seed are recorded only with record_prompt=True.

from PIL import Image
from agate import detect_watermark
print(detect_watermark(Image.open("out.png")))    # {'detected': True, 'bit_accuracy': 1.0, 'release': '003', ...}

detected means the image carries an Agate watermark; the payloads of different Agate releases differ in only a few bits, so release (set only on an exact payload match) is what names the release.

Both marks can be removed: metadata is lost on most re-encodes, and heavy edits or deliberate attacks can erase the watermark. They help tell Agate output apart; they are not proof of origin. Anyone deploying Agate must still label AI-generated or manipulated content themselves where the EU AI Act (Art. 50) or other rules require it. C2PA content credentials are planned, not yet implemented.

Compute and energy

Every GPU job was wrapped in perun. Energy at the wall assumes a PUE of 1.3; CO₂e assumes 30 g/kWh (Swedish SE3 grid). Neither factor is confirmed by NAISS yet; seconds perun did not cover count at idle power, so the totals are a floor.

Preview 003's own lineage, counted from scratch with jobs pro-rated at the steps where it branched off, cost 282.8 GH200-hours, 164.5 kWh and 4.94 kg CO₂e (whole-node est. 207.3 kWh / 6.22 kg), plus 22.5 GH200-hours to encode the 512 px latents and saliency maps. The whole project to date cost 630.4 GPU-hours.

About these energy figures. perun measured GPU power only, through NVML: on the GH200 superchip it did not see the Grace CPU and its memory (Grace has no RAPL counters) or the node's Slingshot network cards, and Arrhenius has no Slurm energy accounting to check against. We calibrated the gap on 2026-09-30 (one node, 4 GH200, 12 load phases, whole-module power cross-checked against NVML's module energy counter to 0.03 %): the Grace CPU and its memory add a near-constant 83-100 W per superchip on top of the GPU reading, and the network cards about 17 W per GPU. At our average GPU power that makes whole-node energy about 1.26x the figures above (range 1.23-1.29; about 1.2 at full GPU load, more for idle-heavy jobs such as evaluation), shown in the whole-node column. The PUE of 1.3 and 30 g/kWh are already in these figures and should not be applied again. About 93.5 % of the project's GPU-hours were measured directly by perun and the rest estimated; our jobs now record whole-superchip power directly.

Training compute. Estimated at ~8e19 FLOP (7.1e19–8.5e19): measured forward FLOPs per image (97.5 GFLOP per 256 px and 255.9 GFLOP per 512 px image for the generator, 10.8 GFLOP for the text encoder at 128 tokens; torch.utils.flop_counter) × the 196.6M images seen in the whole lineage × 3 for the backward pass. Counting the pretraining of the Ettin-68M text encoder we started from (~8e20 FLOP, per its authors) gives ~9e20 FLOP. Both are far below the 1e23 FLOP indicative threshold for general-purpose AI models in the European Commission's guidelines. The compute that third parties used to generate the synthetic training images (FLUX-Reason-6M) is not included.

What went wrong along the way

• Our gradient-spike guard stopped the first 512 px tests at step 183: one running norm, fed by 256 px steps, rejected every (legitimately larger) 512 px step. Fixed with per-resolution averages.
• A tokenizer thread race crashed mr512_long1 at step 13,590 (two prefetch threads sharing one fast tokenizer). ~2.4 GPU-hours lost; a lock now guards every call.
• Feeding the 256 px thinker the full 64 × 64 latent gave texture noise, at any attention temperature; the thinker now reads the subsample plus a learned full-resolution branch.
• 512 px costs attribute binding. Colour binding is lower than at 256 px in every 512 px run so far.
• The QIB gain is not attributed between resolution and the perceptual fine-tune (no control arm).

Limitations and intended use

• Square only, 512 × 512 or 256 × 256. Aspect ratios are not supported yet.
• Text rendering is still unreliable despite the spelled-out quotes; counts above four and colour binding are weak.
• Synthetic training data. Every training image was generated by FLUX.1-dev; Agate inherits its look and biases, and a perceptual loss against those images cannot make it look less synthetic.
• No safety classifier is bundled. Do not use Agate to depict real people or to deceive.
• The browser demo uses fp16 weights and the fast TAESD decoder, so its images are slightly softer than the Python package's.
• Intended for research, education, prototyping and small-footprint deployment.

Licence

MIT, for the code and the weights (see LICENSE). Agate was trained on FLUX-Reason-6M (Apache-2.0 per its dataset card), whose images were generated with FLUX.1-dev. The text encoder is fine-tuned from Ettin-68M (MIT); the SD-VAE and TAESD decoders (MIT) are downloaded from their own repositories.

Why we built Agate

Agate is the result of an architecture study. LogoLabs generates logos, and our customers increasingly need a matching font: every glyph, not a single wordmark. That calls for a small, fast model that generates glyph representations such as signed distance fields (SDFs), which can then be turned into clean vectors. No existing model does this, so there was nothing in that domain to measure a new architecture against.

We therefore ran the study where baselines exist: general text-to-image generation on a large open dataset, scored with established benchmarks (GenEval, Qwen-Image-Bench, FID) and compared against a diffusion-transformer baseline reproduced on the same data. We compared convolutional, transformer and hybrid designs under one evaluation protocol; the winner splits the work between a small transformer planner (the "thinker") and a convolutional renderer. Agate is the artifact of that study, and its scores (Preview 001: 0.550 on GenEval at 260M parameters, equal to SDXL's published score; Preview 003: above SD 1.5 on Qwen-Image-Bench) are evidence that the architecture is sound before we apply it to glyphs.

What we found along the way. A model this small turned out to be a research tool in its own right:

• A cheap testbed for adapter architectures. An Agate fine-tune takes a few GPU-hours, so we could compare adapter designs quickly: rank sweeps, topic-specialist LoRAs, mixture-of-LoRA experts with learned routing, and adapters trained with perceptual objectives, at 2-10 GPU-hours per experiment, roughly a tenth of what the same question costs on a multi-billion-parameter base. It is how we learned, for instance, that adapters trained with plain flow loss quietly undo a perceptually trained base.
• Flow matching at a practical scale. Training a complete text-to-image flow model from scratch in about 150 GPU-hours lets a small team run many full trainings, not one, and study objectives, samplers, resolution transfer and routing that would otherwise need a far larger budget.

Next, we are applying the architecture to glyph and symbol generation for vector-native fonts to go with our wordmarks, traced to SVG by our vectoriser, Inkvec, whose prior we will improve with flow matching.

Why we released it. We decided to release Agate to share these architectural efforts, and so that other companies can benefit from this architecture when they train small models for specialised tasks, with significantly lower compute requirements.

Acknowledgements

We acknowledge EuroHPC JU for awarding the project ID EHPC-AIF-2026PG01-907 access to resources on Arrhenius GPU at NAISS, Sweden.

Thank you to the EuroHPC Joint Undertaking, and to NAISS for running Arrhenius. A small team cannot usually train a text-to-image model from scratch; this allocation made it possible, and made it possible to do it openly. Every LogoLabs model in this card, Preview 003 and every checkpoint it descends from, was trained under that EuroHPC AI Factory allocation. It funded the architecture study behind Agate, described in Why we built Agate above, which serves LogoLabs' work on glyph and symbol generation.

Thanks also to:

• the authors of FLUX-Reason-6M;
• Ettin (JHU CLSP);
• SD-VAE-ft-MSE (Stability AI);
• TAESD (Ollin Boer Bohan);
• GenEval (Ghosh et al.);
• Qwen-Image-Bench (Qwen team);
• perun;
• LPIPS, DINOv2 and UNISAL, used by the perceptual fine-tune;
• SupraLabs, for Supra2-IMG, the baseline this work started from.

More from LogoLabs

LogoLabs makes AI logo generation. Our open releases are all at huggingface.co/Logolabs:

References

Architecture and training:

• Kwon et al., Reviving ConvNeXt for Efficient Convolutional Diffusion Models (FCDM), arXiv:2603.09408: the renderer's block and U-Net.
• Liu et al., A ConvNet for the 2020s, arXiv:2201.03545; Woo et al., ConvNeXt V2 (GRN), arXiv:2301.00808.
• Jabri et al., Scalable Adaptive Computation for Iterative Generation (RIN), arXiv:2212.11972; Jaegle et al., Perceiver / Perceiver IO, arXiv:2103.03206, arXiv:2107.14795: latent cells that read the image.
• Geiping et al., Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach, arXiv:2502.05171: the thinker's looped core.
• Su et al., RoFormer (RoPE), arXiv:2104.09864; Henry et al., Query-Key Normalization, arXiv:2010.04245; Wortsman et al., Small-scale proxies for large-scale Transformer training instabilities, arXiv:2309.14322.
• Perez et al., FiLM, arXiv:1709.07871; Park et al., SPADE, arXiv:1903.07291: per-region steering.
• Zhang et al., ControlNet, arXiv:2302.05543: zero-initialised growth.
• Liu et al., Rectified Flow, arXiv:2209.03003; Lipman et al., Flow Matching, arXiv:2210.02747; Esser et al., SD3, arXiv:2403.03206.
• Ho & Salimans, Classifier-Free Guidance, arXiv:2207.12598; Karras et al., Guiding a Diffusion Model with a Bad Version of Itself (autoguidance), arXiv:2406.02507.
• Weller et al., Ettin (Seq vs Seq), arXiv:2507.11412; Warner et al., ModernBERT, arXiv:2412.13663.
• Rombach et al., Latent Diffusion, arXiv:2112.10752; SD-VAE-ft-MSE; TAESD.
• Loshchilov & Hutter, AdamW, arXiv:1711.05101; Kumar et al., Fine-Tuning can Distort Pretrained Features (LP-FT), arXiv:2202.10054.

Data and evaluation:

• Fang et al., FLUX-Reason-6M & PRISM-Bench, arXiv:2509.09680.
• Ghosh et al., GenEval, arXiv:2310.11513; Cheng et al., Mask2Former, arXiv:2112.01527; Radford et al., CLIP, arXiv:2103.00020.
• Li et al., Qwen-Image-Bench, arXiv:2605.28091; Kwon et al., vLLM, arXiv:2309.06180.
• Heusel et al., FID, arXiv:1706.08500; Stein et al., FD-DINOv2, arXiv:2306.04675; Oquab et al., DINOv2, arXiv:2304.07193.
• Gutiérrez Hermosillo Muriedas et al., perun, Euro-Par 2023.

Compared and related models:

• Podell et al., SDXL, arXiv:2307.01952; Chen et al., PixArt-α, arXiv:2310.00426 and PixArt-Σ, arXiv:2403.04692; Bai et al., Meissonic, arXiv:2410.08261.
• Xie et al., SANA, arXiv:2410.10629; Sehwag et al., MicroDiT, arXiv:2407.15811; Pernias et al., Würstchen, arXiv:2306.00637; Hu et al., SnapGen, arXiv:2412.09619.
• Supra2-IMG, TinyDiT-256, HobbyLM-Image.

The technical report cites 119 works in full.

Added for Preview 003: Esser et al., SD3 (resolution shift), arXiv:2403.03206; Zhang et al., LPIPS, arXiv:1801.03924; Droste et al., UNISAL, arXiv:2003.05477; Hägele et al., Scaling Laws and Compute-Optimal Training Beyond Fixed Training Durations (1−√ cool-down), arXiv:2405.18392.

Citation

@misc{logolabs2026agate003,
  title        = {{Agate Preview 003: a 261M text-to-image model at 512 px}},
  author       = {Deleanu, Stefan-Lucian},
  organization = {LogoLabs},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/Logolabs/agate-preview-003}}
}