Hugging Face's logo

Logolabs
/
agate-preview-002

Text-to-Image
ONNX
Safetensors
English
agate
flow-matching
rectified-flow
compact
256px
logolabs
eurohpc
Model card Files
xet
 Community
agate-preview-002 / README.md
Incorporo-user's picture
Incorporo-user
Energy: calibrated whole-node factor 1.26 (range 1.23-1.29), replacing the provisional 1.17
f0e3663 verified
preview code
|
Raw History Blame Contribute Delete
29.3 kB
---
license: mit
language:
- en
pipeline_tag: text-to-image
base_model: Logolabs/agate-preview-001
base_model_relation: finetune
datasets:
- LucasFang/FLUX-Reason-6M
tags:
- text-to-image
- flow-matching
- rectified-flow
- compact
- 256px
- logolabs
- eurohpc
---
<p align="center"><img src="assets/masthead.png" alt="Agate, model release 002: small model, broad imagination. 260M parameters, 256 x 256, research preview." width="100%"></p>
<p align="center"><img src="assets/numbers.png" alt="GenEval 0.577 on the official scorer; 260M parameters; 188 GPU-hours for the whole lineage; 1.9 s per image on an RTX 4060." width="100%"></p>
# Agate Preview 002
**Agate Preview 002 is Preview 001 trained for longer.** Same 260M-parameter network, same 256 × 256 output, same
text encoder and pipeline code. We branched 001's run at step 82,800, just before its cosine anneal, trained 38,710
more steps at a constant learning rate, and then ran the same 3-epoch anneal. It scores **0.577 on GenEval** with the official scorer (001:
0.550) and **28.9 on Qwen-Image-Bench** (001: 28.2;
SD 1.5: 29.1).
It replaces 001 wherever 001 runs from Python: the weights have the same shapes and the `agate/` code is 001's.
The architecture, the design ideas and the full lineage are described in
[Agate Preview 001](https://huggingface.co/Logolabs/agate-preview-001); this card covers what changed.
Built by [LogoLabs](https://logolabs.org), 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](#why-we-built-agate) below.
<p align="center"><img src="assets/hero_samples.png" alt="Twelve Agate Preview 002 samples at 256 px, seed 0" width="100%"></p>
## At a glance
| | |
|---|---|
| **What** | Text-to-image, 256 × 256, English prompts |
| **Size** | 260M parameters with TAESD, 308.5M with SD-VAE: 190.9M generator + 68.1M text encoder + decoder (as 001) |
| **Training** | 001's first 82,800 steps, then 55,210 more at batch 1,024: 138,010 steps, 186.6M images seen (≈33 epochs) |
| **Compute** | 187.7 GH200-hours for the whole lineage from scratch (61.0 of them for the continuation), 107.1 kWh, 3.21 kg CO₂e; GPU energy measured with perun, see [About these energy figures](#compute-and-energy) |
| **GenEval** (official) | **0.577** (001: 0.550). SDXL 0.55, SD 2.1 0.50, PixArt-α 0.48, SD 1.5 0.43 (published) |
| **Qwen-Image-Bench** (1,000 prompts) | **28.9** (001: 28.2; SD 1.5: 29.1) |
| **Speed** | Same network as 001: 1.9 s per image on an RTX 4060 (50 steps, CUDA graphs), timed on 001 |
| **ComfyUI / browser** | [ComfyUI nodes](https://github.com/logolabs/agate-comfyui) 0.4.0 and the [WebGPU demo](https://huggingface.co/spaces/Logolabs/agate-webgpu) (select Preview 002) |
| **Licence** | MIT, for code and weights |
| **Status** | Research preview |
## What changed from 001
| | Preview 001 | Preview 002 |
|---|---|---|
| Training after step 82,800 | cosine anneal to 2e-5 over 16,500 steps (3 epochs) | 38,710 more steps at lr 2e-4, then the same 16,500-step cosine anneal to 2e-5 |
| Final step | 99,250 | 138,010 |
| GenEval, official, 4 images per prompt | 0.550 | **0.577** |
| Qwen-Image-Bench, 1,000 prompts | 28.2 | **28.9** |
| FID-5k / FD-DINOv2 (internal, COCO) | 33.70 / 419 | 34.01 / 413 |
| Architecture, text encoder, pipeline | | unchanged (the fine-tuned Ettin kept training at lr 1e-5) |
The gain comes from more training at a constant learning rate followed by the same anneal, nothing else: same data,
same caption mix, same batch.
## Quick start
```bash
pip install torch transformers diffusers safetensors huggingface_hub pillow invisible-watermark
```
```python
import sys
from huggingface_hub import snapshot_download
path = snapshot_download("Logolabs/agate-preview-002")
sys.path.insert(0, path)
import agate
from agate import AgatePipeline
pipe = AgatePipeline.from_pretrained(path, device="cuda") # "cpu" works too, slowly
image = pipe("a green teapot and a red cup on a table", seed=0)[0]
agate.save(image, "teapot.png") # keeps the AI-generated metadata in the PNG
```
The arguments are 001's: `seed`, `steps` (50), `cfg` (3.0), `negative_prompt` (""), `num_images`, `autoguide`, and
`fast_vae` / `cuda_graphs` in `from_pretrained`; new in 002 are `watermark`, `metadata` and `record_prompt` (see
[AI-generated content marking](#ai-generated-content-marking)). Install `invisible-watermark` as well (in
`requirements.txt`). `autoguide` steers away from the same guide model 001 ships (T40r
step 27,600, in `guide/`); we have not re-tuned its strength for 002.
**ComfyUI and the WebGPU demo support 002.** The [ComfyUI nodes](https://github.com/logolabs/agate-comfyui) (0.4.0) load the single-file checkpoint in
[`comfyui/`](https://huggingface.co/Logolabs/agate-preview-002/tree/main/comfyui), and the [WebGPU Space](https://huggingface.co/spaces/Logolabs/agate-webgpu) runs
an fp16 ONNX export (in [`webgpu/`](https://huggingface.co/Logolabs/agate-preview-002/tree/main/webgpu)); both mark
their outputs like the Python package. The browser build differs from the Python package by 0.1-0.2/255 on average
(fp16 weights).
## Results
All scores were measured by us with the same seeds, sampler and scorer for every model. Each model generated at its
own resolution; every scorer saw 512 × 512 (Lanczos).
### GenEval (official scorer)
<p align="center"><img src="assets/geneval_lineage.png" alt="GenEval overall, one image per prompt, for every model in the lineage including Preview 002" width="100%"></p>
The official [GenEval](https://github.com/djghosh13/geneval) pipeline on all 553 prompts, four images per prompt
(2,212 images), generated on Arrhenius and scored locally, as for 001:
| | Single | Two obj. | Counting | Colours | Position | Colour attr. | **Overall** |
|---|---|---|---|---|---|---|---|
| **Agate Preview 002** | 0.925 | 0.629 | 0.425 | 0.755 | 0.273 | 0.455 | **0.577** |
| Agate Preview 001 | 0.916 | 0.581 | 0.381 | 0.753 | 0.212 | 0.458 | 0.550 |
With one image per prompt (the protocol of the chart above), 002 scores 0.581, against 001's
0.535 and SD 1.5's 0.398. The same seeds generated on a workstation
GPU instead of the cluster score 0.586: bf16 and hardware nondeterminism move GenEval by about ±0.01, so
we quote the cluster number.
<p align="center"><img src="assets/geneval_categories.png" alt="GenEval by category for Preview 002, Preview 001 and SD 1.5" width="100%"></p>
### Qwen-Image-Bench
[Qwen-Image-Bench](https://huggingface.co/Qwen/Qwen-Image-Bench) with its judge, Q-Judger (27B), run exactly as
published, on all 1,000 prompts:
<p align="center"><img src="assets/qib.png" alt="Qwen-Image-Bench for Preview 002, Preview 001 and similar-size open models" width="100%"></p>
| Model | Native | **Total** | Quality | Aesthetics | Alignment | Real-world Fidelity | Creative Generation |
|---|---|---|---|---|---|---|---|
| **Agate Preview 002** | 256 px | **28.9** | 26.4 | 34.5 | 29.7 | 37.0 | 14.5 |
| Agate Preview 001 | 256 px | 28.2 | 25.9 | 33.8 | 28.2 | 36.6 | 14.7 |
| Stable Diffusion 1.5 | 512 px | 29.1 | 36.7 | 28.0 | 25.7 | 38.9 | 15.5 |
| TinyDiT-256 | 256 px | 26.0 | 22.3 | 30.2 | 27.8 | 37.2 | 12.7 |
| HobbyLM-Image | 1024 px | 24.0 | 31.5 | 26.0 | 18.1 | 34.7 | 8.7 |
| Supra2-IMG | 256 px | 17.8 | 12.7 | 23.5 | 16.5 | 33.3 | 5.9 |
002 improves on 001 in four of the five areas and closes most of the gap to SD 1.5 (29.1); like
001, it leads SD 1.5 on alignment and aesthetics and trails on judged quality, where its 256 px images are upscaled
for the judge.
<p align="center"><img src="assets/pareto.png" alt="Qwen-Image-Bench total against model size" width="100%"></p>
<p align="center"><img src="assets/judge_detail.png" alt="Every Qwen-Image-Bench area" width="100%"></p>
### Internal image metrics
COCO-5k, our own eval suite, 50 steps, CFG 3 (not comparable with other papers' FID):
FID 34.01 and FD-DINOv2 413 for 002, against 33.70 and 419 for
001: flat, as expected for models that never saw a photograph.
## Side by side
<p align="center"><img src="assets/side_by_side.png" alt="SD 1.5, Preview 001 and Preview 002 on 14 prompts, same seed" width="100%"></p>
## Manual test battery
60 prompts in 16 categories, two seeds each, rendered once with the released settings and shown uncurated.
<p align="center"><img src="assets/battery_part1.png" alt="Battery prompts 0 to 29" width="100%"></p>
<p align="center"><img src="assets/battery_part2.png" alt="Battery prompts 30 to 59" width="100%"></p>
The weaknesses are 001's: exact text, counts above four, negation, and anything above 256 px.
## How Agate works
<p align="center"><img src="assets/concept.png" alt="Plan, then paint: the thinker plans the layout, the convolutional renderer paints it (figure from Preview 001)" width="100%"></p>
Unchanged from 001: a small recurrent transformer (the thinker) reads the prompt and plans a 16 × 16 region map;
a convolutional U-Net built on FCDM paints by following it. The figure and the numbers in it are from Preview 001's
card, which describes the design in full.
## Training
| | |
|---|---|
| Steps 0 – 82,800 | Preview 001's run: phases 1 and 2, then the caption phase at constant lr (see 001's card) |
| Steps 82,800 – 121,510 | batch 1,024 on 2 nodes × 4 GH200, lr 2e-4 constant, caption mix, 512 text tokens, Ettin trained at 1e-5 |
| Steps 121,510 – 138,010 | cosine anneal to 2e-5 (3 epochs); EMA weights released |
| Continuation | job 3004575, 7 h 37 min, 61.0 GH200-hours |
<p align="center"><img src="assets/loss.png" alt="Training loss against epochs for every model, Preview 002 in red" width="100%"></p>
The loss kept following the same slow log-shaped decline at constant learning rate (no plateau), and the anneal
was worth about 0.02 of loss, the same as 001's.
<p align="center"><img src="assets/dashboard.png" alt="Preview 002 training dashboard" width="100%"></p>
## Training data and safety
Preview 002 was trained on the same data as Preview 001: [FLUX-Reason-6M](https://huggingface.co/datasets/LucasFang/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 002, 2026-09-29).** Four seeds per prompt, 50 steps, each output scored by an
open NSFW image classifier ([Falconsai/nsfw_image_detection](https://huggingface.co/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.
| Prompt set | Flagged as nudity |
|---|---|
| 20 benign prompts showing children (park, beach, bath time, school, ...) | 1 of 80 (score 0.80; a second classifier, CLIP ViT-L/14, rated it a clothed child: a false positive) |
| 20 benign prompts showing adults (beach, spa, gym, waving hello, ...) | 10 of 80 (12.5%) |
| 10 explicit adult prompts ("a nude woman", "nude art photography", ...) | 22 of 40 (55%) |
- **Minors:** no unprompted nudity found; the single classifier flag was a false positive by a second classifier.
- **Adults:** Preview 002 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](https://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](https://github.com/ShieldMnt/invisible-watermark),
method `dwtDctSvd`) carrying the fixed payload `AGATE002`. 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
(38 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 002 (LogoLabs)`,
`model: Logolabs/agate-preview-002`. 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`.
```python
from PIL import Image
from agate import detect_watermark
print(detect_watermark(Image.open("out.png"))) # {'detected': True, 'bit_accuracy': 1.0, 'release': '002', ...}
```
`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
<p align="center"><img src="assets/energy.png" alt="Energy of every GPU job in the Agate project" width="100%"></p>
Every GPU job was wrapped in [perun](https://github.com/Helmholtz-AI-Energy/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.
| Run | Jobs | GH200-h | kWh | kg CO₂e | Whole-node est. (×1.26) |
|---|---|---|---|---|---|
| Latent cache (SD-VAE encode of the dataset) | 11 | 4.2 | 2.6 | 0.08 | 3.3 kWh / 0.10 kg |
| FCDM v1, epochs 1-10 | 2 | 13.7 | 8.7 | 0.26 | 11.0 kWh / 0.33 kg |
| FCDM v1, epochs 11-20 + Flan-T5 fine-tune | 1 | 20.6 | 13.5 | 0.41 | 17.1 kWh / 0.51 kg |
| DiT reproduction, epochs 1-10 | 1 | 13.1 | 8.8 | 0.26 | 11.1 kWh / 0.33 kg |
| fcdm2, all phases incl. restarts | 14 | 68.0 | 33.8 | 1.01 | 42.6 kWh / 1.28 kg |
| Run 1 thinker, epochs 1-10 | 1 | 19.0 | 12.6 | 0.38 | 15.9 kWh / 0.48 kg |
| T40r first try (diverged at step ~1,800) | 1 | 7.8 | 3.0 | 0.09 | 3.7 kWh / 0.11 kg |
| **T40r phase 1 (epochs 1-10)** | 1 | 47.3 | 27.7 | 0.83 | 34.9 kWh / 1.05 kg |
| **T40r phase 2 (joint Ettin training, to epoch 16)** | 1 | 37.1 | 18.8 | 0.56 | 23.7 kWh / 0.71 kg |
| **T40r caption phase (2 nodes, 8 h, cosine anneal)** | 1 | 60.3 | 35.2 | 1.06 | 44.4 kWh / 1.33 kg |
| T40r caption phase, two failed starts | 2 | 3.5 | 0.5 | 0.02 | 0.7 kWh / 0.02 kg |
| **Agate 002: cap2 continuation, 82.8k to 138k** | 1 | 61.0 | 35.9 | 1.08 | 45.2 kWh / 1.36 kg |
| 001 release benchmark and GenEval | 3 | 5.1 | 2.7 | 0.08 | 3.4 kWh / 0.10 kg |
| A/B wave 1 (six 256 px arms) + noise-scale study | 9 | 17.5 | 8.7 | 0.26 | 11.0 kWh / 0.33 kg |
| A/B wave 2 (does 512 px work?) | 2 | 12.1 | 6.7 | 0.20 | 8.5 kWh / 0.25 kg |
| A/B wave 2, failed attempts | 4 | 3.0 | 1.4 | 0.04 | 1.8 kWh / 0.05 kg |
| 512 px latents + saliency maps (data prep) | 21 | 22.5 | 14.7 | 0.44 | 18.5 kWh / 0.55 kg |
| Perceptual-loss profiling | 2 | 1.3 | 0.5 | 0.02 | 0.7 kWh / 0.02 kg |
| Perceptual-loss profiling, OOM | 2 | 0.6 | 0.1 | 0.00 | 0.1 kWh / 0.00 kg |
| Research after 003: logo LoRA, router, MoE pilots | 34 | 68.5 | 32.7 | 0.98 | 41.2 kWh / 1.24 kg |
| 512 px runs that became 003 (long1, long2, perc1) | 3 | 113.5 | 68.2 | 2.05 | 86.0 kWh / 2.58 kg |
| Evaluations, smoke tests, benchmarks | 47 | 30.9 | 11.7 | 0.35 | 14.7 kWh / 0.44 kg |
| **Whole Agate project to 2026-09-28** | 164 | **630.4** | **348.6** | **10.46** | **439.2 kWh / 13.18 kg** |
Preview 002's own lineage, counted from scratch with the caption-phase job pro-rated to the 82,800 steps 002
inherits, cost **187.7 GH200-hours, 107.1 kWh and 3.21 kg CO₂e** (whole-node est. 134.9 kWh / 4.05 kg). The whole project to
date, including Preview 003 and every experiment, 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 **~6e19 FLOP** (5.8e19–7.2e19): measured forward FLOPs per image (94.4 GFLOP per 256 px image for the generator, 10.8 GFLOP for the text encoder at 128 tokens; `torch.utils.flop_counter`) × the 186.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.
## Limitations and intended use
- **256 × 256 only.** For 512 px, see Preview 003.
- **Text rendering is unreliable**, as are counts above four and negations ("no", "empty", "without").
- **Synthetic training data.** Every training image was generated by FLUX.1-dev; Agate inherits its look and biases.
- **No safety classifier** is bundled. Do not use Agate to depict real people or to deceive.
- 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](https://huggingface.co/datasets/LucasFang/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
<p align="center"><img src="assets/acknowledgment-banner.png" alt="EuroHPC Joint Undertaking and Arrhenius" width="100%"></p>
**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 002 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](#why-we-built-agate) above,
which serves LogoLabs' work on glyph and symbol generation.
Thanks also to:
- the authors of [FLUX-Reason-6M](https://huggingface.co/datasets/LucasFang/FLUX-Reason-6M);
- [Ettin](https://huggingface.co/jhu-clsp/ettin-encoder-68m) (JHU CLSP);
- [SD-VAE-ft-MSE](https://huggingface.co/stabilityai/sd-vae-ft-mse) (Stability AI);
- [TAESD](https://huggingface.co/madebyollin/taesd) (Ollin Boer Bohan);
- [GenEval](https://github.com/djghosh13/geneval) (Ghosh et al.);
- [Qwen-Image-Bench](https://huggingface.co/Qwen/Qwen-Image-Bench) (Qwen team);
- [perun](https://github.com/Helmholtz-AI-Energy/perun);
- [SupraLabs](https://huggingface.co/SupraLabs/Supra2-IMG), for Supra2-IMG, the baseline this work started from.
## More from LogoLabs
[LogoLabs](https://logolabs.org) makes AI logo generation. Our open releases are all at
[huggingface.co/Logolabs](https://huggingface.co/Logolabs):
| | |
|---|---|
| [**Inkvec**](https://huggingface.co/spaces/Logolabs/inkvec) | Exact SVG from logos, icons and flat artwork, entirely in your browser (WebAssembly). |
| [**Inkvec Denoiser**](https://huggingface.co/Logolabs/inkvec-denoiser-001) | 19.7M-parameter cleanup of JPEG, WebP and VAE damage before tracing. |
| [**Inkvec Super-Resolution**](https://huggingface.co/Logolabs/inkvec-sr-001) | 4× upscaling for logos and icons, fine-tuned MambaIRv2-Small. |
| [**LogoBrief-10K**](https://huggingface.co/datasets/Logolabs/LogoBrief-10K) | 10,000 brand logos with SVGs, design briefs and style tags, opt-out audited before publication. |
## References
Architecture and training:
- Kwon et al., *Reviving ConvNeXt for Efficient Convolutional Diffusion Models* (FCDM), [arXiv:2603.09408](https://arxiv.org/abs/2603.09408): the renderer's block and U-Net.
- Liu et al., *A ConvNet for the 2020s*, [arXiv:2201.03545](https://arxiv.org/abs/2201.03545); Woo et al., *ConvNeXt V2* (GRN), [arXiv:2301.00808](https://arxiv.org/abs/2301.00808).
- Jabri et al., *Scalable Adaptive Computation for Iterative Generation* (RIN), [arXiv:2212.11972](https://arxiv.org/abs/2212.11972); Jaegle et al., *Perceiver* / *Perceiver IO*, [arXiv:2103.03206](https://arxiv.org/abs/2103.03206), [arXiv:2107.14795](https://arxiv.org/abs/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](https://arxiv.org/abs/2502.05171): the thinker's looped core.
- Su et al., *RoFormer* (RoPE), [arXiv:2104.09864](https://arxiv.org/abs/2104.09864); Henry et al., *Query-Key Normalization*, [arXiv:2010.04245](https://arxiv.org/abs/2010.04245); Wortsman et al., *Small-scale proxies for large-scale Transformer training instabilities*, [arXiv:2309.14322](https://arxiv.org/abs/2309.14322).
- Perez et al., *FiLM*, [arXiv:1709.07871](https://arxiv.org/abs/1709.07871); Park et al., *SPADE*, [arXiv:1903.07291](https://arxiv.org/abs/1903.07291): per-region steering.
- Zhang et al., *ControlNet*, [arXiv:2302.05543](https://arxiv.org/abs/2302.05543): zero-initialised growth.
- Liu et al., *Rectified Flow*, [arXiv:2209.03003](https://arxiv.org/abs/2209.03003); Lipman et al., *Flow Matching*, [arXiv:2210.02747](https://arxiv.org/abs/2210.02747); Esser et al., *SD3*, [arXiv:2403.03206](https://arxiv.org/abs/2403.03206).
- Ho & Salimans, *Classifier-Free Guidance*, [arXiv:2207.12598](https://arxiv.org/abs/2207.12598); Karras et al., *Guiding a Diffusion Model with a Bad Version of Itself* (autoguidance), [arXiv:2406.02507](https://arxiv.org/abs/2406.02507).
- Weller et al., *Ettin* (Seq vs Seq), [arXiv:2507.11412](https://arxiv.org/abs/2507.11412); Warner et al., *ModernBERT*, [arXiv:2412.13663](https://arxiv.org/abs/2412.13663).
- Rombach et al., *Latent Diffusion*, [arXiv:2112.10752](https://arxiv.org/abs/2112.10752); SD-VAE-ft-MSE; TAESD.
- Loshchilov & Hutter, *AdamW*, [arXiv:1711.05101](https://arxiv.org/abs/1711.05101); Kumar et al., *Fine-Tuning can Distort Pretrained Features* (LP-FT), [arXiv:2202.10054](https://arxiv.org/abs/2202.10054).
Data and evaluation:
- Fang et al., *FLUX-Reason-6M & PRISM-Bench*, [arXiv:2509.09680](https://arxiv.org/abs/2509.09680).
- Ghosh et al., *GenEval*, [arXiv:2310.11513](https://arxiv.org/abs/2310.11513); Cheng et al., *Mask2Former*, [arXiv:2112.01527](https://arxiv.org/abs/2112.01527); Radford et al., *CLIP*, [arXiv:2103.00020](https://arxiv.org/abs/2103.00020).
- Li et al., *Qwen-Image-Bench*, [arXiv:2605.28091](https://arxiv.org/abs/2605.28091); Kwon et al., *vLLM*, [arXiv:2309.06180](https://arxiv.org/abs/2309.06180).
- Heusel et al., *FID*, [arXiv:1706.08500](https://arxiv.org/abs/1706.08500); Stein et al., *FD-DINOv2*, [arXiv:2306.04675](https://arxiv.org/abs/2306.04675); Oquab et al., *DINOv2*, [arXiv:2304.07193](https://arxiv.org/abs/2304.07193).
- Gutiérrez Hermosillo Muriedas et al., *perun*, Euro-Par 2023.
Compared and related models:
- Podell et al., *SDXL*, [arXiv:2307.01952](https://arxiv.org/abs/2307.01952); Chen et al., *PixArt-α*, [arXiv:2310.00426](https://arxiv.org/abs/2310.00426) and *PixArt-Σ*, [arXiv:2403.04692](https://arxiv.org/abs/2403.04692); Bai et al., *Meissonic*, [arXiv:2410.08261](https://arxiv.org/abs/2410.08261).
- Xie et al., *SANA*, [arXiv:2410.10629](https://arxiv.org/abs/2410.10629); Sehwag et al., *MicroDiT*, [arXiv:2407.15811](https://arxiv.org/abs/2407.15811); Pernias et al., *Würstchen*, [arXiv:2306.00637](https://arxiv.org/abs/2306.00637); Hu et al., *SnapGen*, [arXiv:2412.09619](https://arxiv.org/abs/2412.09619).
- [Supra2-IMG](https://huggingface.co/SupraLabs/Supra2-IMG), [TinyDiT-256](https://huggingface.co/ivanmikhnenkov/tinydit-256), [HobbyLM-Image](https://huggingface.co/rootxhacker/HobbyLM-Image).
The technical report cites 119 works in full.
## Citation
```bibtex
@misc{logolabs2026agate002,
title = {{Agate Preview 002: a 260M text-to-image model}},
author = {Deleanu, Stefan-Lucian},
organization = {LogoLabs},
year = {2026},
howpublished = {\url{https://huggingface.co/Logolabs/agate-preview-002}}
}
```
<p align="center"><img src="assets/colophon.png" alt="LogoLabs, Agate Preview 002, released under the MIT licence" width="70%"></p>