← Back to blog
AiAbout 6 min read

A Two-Person Lab Trained an Image Model for $21,038. It Cannot Draw a Word.

Published Nov 13, 2026
A Two-Person Lab Trained an Image Model for $21,038. It Cannot Draw a Word.

Linum is two people. Sahil and Manu Chopra train video models from scratch, publish the field notes, and have no interest in pretending a research checkpoint is a product. On November 4 they put a text-to-image model on Hugging Face with Apache 2.0 weights, a GitHub repo that runs without an API key, and a blog post that includes the invoice.

The invoice says $21,038.

That number is the reason the post hit 235 points on Hacker News and got picked apart by four separate newsletters within a week. Most open image models arrive with a press release and a leaderboard position. This one arrived with 8,415 H100-hours at $2.50 an hour, run on 64 GPUs under FSDP2, and a list of prompts it fails.

What the money bought

Pretraining cost $20,348: 8,139 H100-hours, 610 million samples at 512 pixels, then 50 million at 1024. Post-training added 276 hours, or $690, using a variant of Finite Difference Flow Optimization with a mix of automated and human judges.

The model is called P-JiT 21K, short for Pyramid-JiT. It has 2.18 billion parameters at sampling time and about 2.42 billion during training, where the extra weight belongs to heads that get thrown away. The text encoder is a frozen Qwen3.5-4B, read at layers 7, 15 and 27.

Two architectural choices explain why the bill is this low, and both of them are about tokens.

There is no VAE. Nearly every image model you can name is a latent diffusion model: a separately trained autoencoder squeezes the image into a compact space, the diffusion transformer learns to generate inside that space, and the decoder turns latents back into pixels. P-JiT deletes both ends of that pipeline and works on raw pixels.

The patches are also coarser. Images are cut into 32 by 32 pixel blocks, each one a 3,072-value RGB chunk projected down to 1,024 dimensions. Most latent models patch at 16 by 16. A 512 by 512 image becomes 256 image tokens here instead of 1,024, and attention cost falls with the square of the token count. Four times fewer tokens is sixteen times less attention work.

A small server rack standing alone in an empty concrete warehouse under one work light.

The third trick is supervision. Readout heads after trunk blocks 10 and 16 predict the clean image at quarter and half resolution, which hands the early layers a gradient signal instead of making them wait for the output of block 22. The authors report the architecture converges in 11 times fewer samples than their previous latent model, Linum v2. That comparison is against their own baseline, so treat the multiplier as a claim with a receipt attached, not a universal law.

The part most releases leave out

P-JiT cannot render text. Linum filtered images containing rendered text out of the training data, which means no posters, no signs, no infographics, no product packaging with legible labels. Prompts that ask for lettering get rejected by the prompt upsampler rather than turned into garbled glyphs.

The model also struggles with full bodies, scenes containing many objects or people, interactions between people, and world knowledge in general. The field notes show failure examples: limbs that bend the wrong way, objects that merge into each other. Linum's own guess is that a 7B model plus more post-training would help, and calls diffusion post-training "a very young discipline."

There are no FID scores, no human preference rates, no head-to-head against FLUX 3 Image or Qwen-Image 2.1. What exists is a 249-image gallery and a validation loss curve on 20,480 square images, with a visible spike to 0.157 at 80 million samples when the noise schedule widened.

That combination, a public gallery and a public failure list, is rarer than it should be. A curated gallery tells you what a team considers its ceiling. A failure list tells you what it considers honest.

The disclosure nobody expected

Buried in the release is a line that generated its own thread: Claude Opus 5.5 wrote the repository and the model card from Linum's internal experiment code, with both brothers reviewing the output.

People read that two ways. One camp sees slop risk, a model card written by a model. The other notices that the expensive part, 64 rented H100s and a noise schedule that had to be widened mid-run, was still done by two humans who understood what they were looking at. The code being generated is not the interesting claim. The training being real is.

What you actually get

The weights are an 8.7 GB fp32 DiT plus a separately downloaded Qwen3.5-4B encoder. generate.py works with no key. The model samples 50 Euler steps with adaptive projected guidance at scale 15, and outputs at five sizes between 1024 by 1024 and 1280 by 720.

It was trained on dense captions of 50 to 80 words, so short prompts degrade badly. To compensate, the repo ships an upsampler that expands a short prompt into a full caption through Claude Opus 5.5 on OpenRouter. There is a --no_upsample flag for people who want to see what their own phrasing does.

There is also an MLX port that runs on an M4 Pro, which the release notes time at 72 seconds per image.

Open weights, closed data

One distinction worth being precise about, because the licensing language gets sloppy fast. The weights are Apache 2.0, the inference code is Apache 2.0, and the training data is not released. That makes P-JiT open weights rather than open source in the strict sense, which is the same position most "open" image models occupy. You can run it, fine-tune it, ship it inside a commercial product, and you cannot reproduce the training run.

The practical consequence for anyone fine-tuning is that the frozen Qwen3.5-4B encoder is doing a lot of the semantic work, and the DiT on top of it was trained on captions of 50 to 80 words. If your data looks nothing like dense descriptive captions, for instance if it is product SKUs with six-word labels, the model will need post-training to meet you where you are. Linum's own framing is that post-training for diffusion is a young discipline, which is a polite way of saying the tools are immature and the results are uneven.

Why a $21K checkpoint matters

Production teams should not swap anything for this. If you need legible text on packaging, P-JiT is the wrong tool today, and Linum says so before you download it.

The value is elsewhere. Two people with a rented cluster and a published recipe produced a usable 2B image model for the price of a used car, and every hyperparameter is on the page: losses, noise schedules, optimizer settings, batch sizes, EMA half-lives. For a research group that wants to study pixel-space diffusion or fine-tune a small model on a narrow domain, that is a starting point that did not exist a year ago.

It also resets a conversation about cost. When a frontier lab ships an image model, the compute number is a rumor. Here it is $2.50 times 8,415, and you can check the arithmetic yourself.

The interesting question is what the next two-person lab does with the same budget, now that the recipe, the pitfalls and the failure modes are all public.

Related articles

Google replaced the model behind Search, and the number that moved was a shell benchmark

Gemini 4 Hydrogen became the default on 12 November, taking over from Gemini 3.8 Flash across Search, the Gemini app and the developer API. It runs about 2.5 times faster, scores 57% on Terminal-Bench 4.1 where its predecessor scored 18.2%, and costs $1.50 in and $7.50 out per million tokens.

Three ways a coding agent wastes money, measured on 30 repositories

TokenEconomizer watches what an agent did in a repository you work in often, then stops it from rediscovering the same build command, loading tools it never uses and looping on one error. Across five agent and model combinations it cut mean cost by 18.4% to 30.9%, cheaper in all 30 repository cells, with Pass@1 up in four of five.

earshot gives coding agents 922 sounds, and every one is rendered from code

An agent can write a game, an interface or a film and never hear any of it. earshot answers requests like "three variations of a footstep on gravel" from a catalogue of 922 designs built from public-domain recordings, with no audio files in the repository at all. It runs on CPU, as a CLI, a Python package, an MCP server and a Claude Code plugin.

The agents stealing API keys were not sophisticated. The gateways were open.

Amazon's decoy servers spent October posing as inference APIs and logged agents built on ARTEX pulling provider keys out of LiteLLM, Dify, Langflow and Open WebUI. The way in was a default master key and a half-finished install. ARTEX itself ships with budgets, scope gates and evidence for every finding.