Udgam Labs Trains 152M Chat Model From Scratch for $146

TL;DR

• Udgam Labs released Laghu, a 152-million-parameter English chat model trained from scratch. The main pretraining run cost $146.26 on eight A100 GPUs over 13.2 hours.
• The whole project cost about $194. The release includes seven model repositories, two datasets, training code on GitHub and a technical report.
• The model runs in a browser from a 163 MB file, with a 16K context window and an optional thinking mode.
• It is weak on instruction following and math, and the team says it missed its own pre-registered targets.

A $146 pretraining bill, itemized

Udgam Labs published Laghu on October 22, 2026, and the pitch is refreshingly plain. In the team’s words: “Laghu is a 152M-parameter English chat model. We trained it from scratch: a random starting point, our own 32,768-token tokenizer and our own data recipe.”

The main pretraining run cost $146.26. That is eight A100 GPUs for 13.2 hours. The team puts the whole project at about $194, which covers everything around that core run.

The model is small on purpose. The recommended file is 163 MB, small enough to run in a browser, and the context window is 16,384 tokens. Supervised fine-tuning used 41,467 conversation pairs, and there is an optional thinking mode if you want it.

The release itself is the bigger deal. It covers seven model repositories, two datasets, training code on GitHub, evaluation logs and a technical report. Weights come in multiple formats, including raw optimizer checkpoints. The exact failed runs and itemized expenses are in there too. You can read the original post on Hugging Face.

The receipts matter more than the model

Most open model releases are a finished loaf in a bakery window. You can eat it, photograph it, even re-slice it. Laghu hands you the flour receipts, the burnt trays and the oven logs. That is a different kind of gift.

Why does that matter? Because a lot of small-model claims are impossible to check. Somebody says they trained something cheaply, and you cannot tell what was left out. Here, the cost is broken down, the failures are published, and the code is public. I have read plenty of release posts that ask for trust. This one mostly asks for scrutiny.

The competitive picture is honest too. Udgam Labs benchmarked Laghu against SmolLM2-135M-Instruct and Falcon-H1-Tiny-90M-Instruct. On judged chat quality, Laghu is competitive with SmolLM2-135M. It lags Falcon-H1-Tiny-90M-Instruct, which used roughly 12x more compute.

That second comparison is the interesting one. Falcon’s small model spent about twelve times the compute and still only beat Laghu on chat quality. So how much of a small model’s quality is budget, and how much is recipe? Laghu does not settle that. But it puts a $146 data point on the table.

And the weaknesses are real. The creators say Laghu did not clear its pre-registered target bars across all three test categories. Instruction following scored 26.1 on IFEval. Math reasoning hit 7.9% on GSM8K. They also admit losing some intermediate pretraining checkpoints. Nobody should call this a general-purpose assistant.

Still, I would rather read a release that lists its misses than one that hides them. A team that pre-registers targets and then publishes the failure is doing something most benchmark charts never do.

Why tiny models keep pulling researchers in

Small language models that run locally in browsers or on consumer devices have become a major research focus. The appeal is obvious. No server round trip, no per-token bill, and a file you can ship the way you would ship an image.

The catch is documentation. Plenty of groups release weights. Far fewer release the end-to-end recipe, the data builders, the optimizer checkpoints and the exact training costs. That kind of full transparency remains rare in open-source AI, and it is the gap Laghu goes after.

It is worth being precise about what Laghu is. It is an English-only chat model at 152 million parameters, trained with its own tokenizer and its own data recipe rather than fine-tuned from someone else’s weights. That is why the $146.26 figure is meaningful. It is the cost of the whole pretraining run, not a patch applied to a model somebody else paid to build.

The scores are the team’s own reported results. Treat them as a starting point for replication, not a final verdict. The good news is the release is built so that anyone can try.

Three things to check next

First, replication. The code, datasets and logs are public, so the obvious test is whether outside teams can reproduce the run near the reported $146.26 and land in the same quality range. A claim like this gets stronger or weaker fast once other people run it.

Second, the weak spots. Instruction following at 26.1 on IFEval and 7.9% on GSM8K leave a lot of room. Watch whether the released recipe and datasets let others improve those numbers without blowing the budget.

Third, the transparency standard itself. If other small-model teams start publishing failed runs and itemized costs, Laghu will have changed what a release is expected to include. If they do not, it will stay a rare exception.