Laghu
A 152M chat model trained from scratch for $146. Everything is open.
It thinks before it answers (on/off), holds multi-turn conversations and chats, in 163 MB that runs in your browser.
Laghu is a small English chat model by Udgam Labs, with 152 million parameters and a switch to think before it answers. We trained it from scratch: the main run took 13.2 hours on eight A100 GPUs and cost $146, the whole project about $194. We publish everything it took, failures included.
In our tests it is level with SmolLM2-135M-Instruct on chat quality and multi-turn conversation. It is not the best small chat model: Falcon-H1-Tiny-90M-Instruct, trained with about 12× Laghu’s compute and a preference-tuning stage, is ahead on all three of our chat tests, and Laghu’s maths (GSM8K 7.9%) and instruction following (IFEval 26.1) are weak.
Try it now · in your browser · free, no login
Chat with Laghu on your own device.
Laghu runs entirely inside this tab: the 163 MB model downloads once and is kept by your browser, and your messages never leave your device.
Works best on a laptop or a recent phone with a good connection.
The conversation appears here.
Laghu is a small research model: it is often wrong on facts, arithmetic and code, so check anything that matters. Its safety training is light, so a filter on this page declines clearly harmful requests. Speed depends on your device.
The result
Level with SmolLM2-135M-Instruct in chat. Behind Falcon-H1-Tiny-90M-Instruct.
Measured with one harness and the same items for every model, Laghu is level with SmolLM2-135M-Instruct on judged chat quality (51.0% win rate) and multi-turn follow-ups (41.7% against 37.5%), and ahead of it on maths with thinking (GSM8K 7.9% against 1.8%). It matches our own 384M model Gargi on chat quality and multi-turn at 40% of its size (no significant difference), and trails it on maths.
Its base model predicts text published in September and October 2026 better than SmolLM2-135M and Falcon-H1-Tiny-90M-Base: 0.919 bits per byte against 0.941 and 0.979, lower is better (152M parameters against 135M and 91M).
Falcon-H1-Tiny-90M-Instruct is ahead on all three chat tests: 23.3% against 7.9% on maths, 54.9% against 41.7% on multi-turn, and Laghu’s win rate against it on chat quality is 28.7%. It was trained with about 12× Laghu’s compute and a preference-tuning stage. Laghu’s instruction following is weak too: IFEval 26.1 against Falcon’s 60.8.
- Parameters
- 152M
- 151.8M by the model’s own count. English, with a thinking on/off switch
- Main pretraining run
- $146
- 8× A100 80GB for 13.2 hours. About $194 for the whole project
- Training tokens read
- ≈71B
- All stages: about 70B in pretraining, 1.0B in the 32K stretch, 0.06B in fine-tuning
- Context
- 16K
- A hidden code is found 96% of the time at 16K tokens, never at 24K or 32K
New text: ahead of SmolLM2-135M, from about 28× fewer tokens
Bits per byte measures how well a model predicts text it has never seen; lower is better. On 1,695 Wikipedia pages and arXiv abstracts published in September and October 2026, after these models were trained, Laghu-Base scores 0.919, SmolLM2-135M 0.941 and Falcon-H1-Tiny-90M-Base 0.979 (152M parameters against 135M and 91M). The differences hold in a paired bootstrap over the documents.
SmolLM2-135M was pretrained on 2 trillion tokens, about 28× Laghu’s 71 billion, and Falcon-H1-Tiny-90M on 800 billion, about 11×.
The lead is on new text. On five commonsense benchmarks Laghu-Base trails SmolLM2-135M (49.9 against 51.8). In chat, Falcon-H1-Tiny-90M-Instruct, trained with about 12× Laghu’s compute and a preference-tuning stage, is ahead on all three of our chat tests, and Laghu’s maths (GSM8K 7.9%) and instruction following (IFEval 26.1) are weak.
- Laghu-Base · 152M0.919 bits per byte
- ≈71B training tokens
- SmolLM2-135M · 135M0.941 bits per byte
- 2T training tokens
- Falcon-H1-Tiny-90M-Base · 91M0.979 bits per byte
- 800B training tokens
1,695 Wikipedia pages and arXiv abstracts published in September and October 2026; one scorer, same documents. Tokens in each model’s own tokenizer, so the ratios are approximate; SmolLM2-135M’s and Falcon-H1-Tiny-90M’s as published by their authors.
How it compares
Before measuring Laghu, we wrote down three chat tests, three rivals of its size and the statistics, and set the bar for calling it best in its class: ahead of every rival in all three tests. It is ahead of SmolLM2-135M-Instruct and MobileLLM-R1.5-140M on maths, level with SmolLM2-135M-Instruct on multi-turn and chat quality, and behind Falcon-H1-Tiny-90M-Instruct on all three. So it did not clear the bar, and we publish every result as measured.

| Test | Laghu152M | SmolLM2-135M-Instruct135M | Falcon-H1-Tiny-90M-Instruct91M | MobileLLM-R1.5-140M140M |
|---|---|---|---|---|
| Maths with thinkingGSM8K test, 1,319 problems, % right. Strict: a reply cut off at the length limit counts as wrong | 7.9% | 1.8%Laghu ahead | 23.3%Laghu behind | 0.0%Laghu ahead |
| Multi-turnFollow-up answered right, % of 144 checkable items | 41.7% | 37.5%Level | 54.9%Laghu behind | 3.5%Laghu ahead |
| Chat qualityLaghu’s win rate against the rival, judged by DeepSeek-V4.1-Flash, 95% interval; 50% means level | – | 51.0%46.5–55.5Level | 28.7%24.0–33.6Laghu behind | 57.3%27.0–76.2Level |
Measured by us on 19 October 2026 with one harness for every model: vLLM, bf16, greedy decoding, each model’s own chat template and the same items. Chat quality is Laghu’s length-controlled win rate in pairwise judging by DeepSeek-V4.1-Flash, 324 held-out prompts in both orders, with its 95% interval; 50% means level. Verdicts are after a Holm correction over the nine comparisons, which we fixed in advance. Against MobileLLM-R1.5 the raw win rate of 91.0% is length-confounded, and the length-controlled 57.3% has a wide interval.
MobileLLM-R1.5-140M results are reported for noncommercial research under the FAIR Noncommercial Research License; we acknowledge Meta’s materials.
Against our own larger models
Laghu matches our 384M Gargi on chat quality and multi-turn at 40% of its size (no significant difference), and trails it on maths.
- Chat quality: Laghu’s win rate against Gargi (384M) is 45.9%p = 0.06, no significant difference
- Multi-turn: Laghu 41.7%, Gargi (384M) 49.3%p = 0.12, no significant difference
- Multi-turn: Laghu 41.7%, Udgam-384M-Chat 40.3%p = 0.89, no significant difference
- Maths with thinking: Laghu 7.9%, Gargi (384M) 35.6%Laghu trails

Other measurements, reported, not claimed
| Check | Laghu, thinking off | Laghu, thinking on | Falcon-H1-Tiny-90M-Instruct | Gargi (384M), better mode |
|---|---|---|---|---|
| IFEval, prompt-level strict | 26.1 | 17.7 | 60.8 | 26.4 |
| GSM8K (last number in the reply) | 4.8 | 8.0 | 23.3 | 35.6 |
| MATH-500, levels 1–3 (238 problems) | 5.5 | 6.3 | 23.9 | 19.3 |
| GSM8K asked as the second turn | – | 8.0 | 27.0 | 37.0 |
| Replies that loop to the length limit, greedy (324 prompts) % | 8.3 | 12.0 | 0.3 | 11.7 |
| Replies that loop, with the shipped sampling % | 1.2 | 1.9 | 0.0 | 2.5 |
Same harness. bf16 greedy decoding is not batch-invariant at this size (for Laghu, 32 of 40 check items gave the same first 512 tokens batched and one at a time), so treat differences of a point or two as noise.
The base model
Before fine-tuning, a language model only predicts the next piece of text. One way to measure it is bits per byte: how surprised the model is by text it has never seen, lower is better. On new text, written after every model here was trained, Laghu-Base is ahead of SmolLM2-135M and Falcon-H1-Tiny-90M-Base, and just behind our 2.5× larger Gargi-Base.
| Model | Params | New text (1,695 documents) | Web (580) | Reasoning (1,179) |
|---|---|---|---|---|
| Laghu-Base | 152M | 0.919 | 0.858 | 0.693 |
| Gargi-Base (ours) | 384M | 0.914 | 0.850 | 0.686 |
| SmolLM2-135M | 135M | 0.941 | 0.858 | 0.752 |
| Falcon-H1-Tiny-90M-Base | 91M | 0.979 | 0.910 | 0.769 |
| Udgam-384M-Base (ours) | 384M | 0.937 | 0.863 | 0.699 |
| SmolLM2-360M | 360M | 0.850 | 0.788 | 0.678 |
New text is 1,695 English Wikipedia pages created between 1 September and 15 October 2026 and arXiv abstracts submitted 1–15 October 2026, after every model here was trained.
Paired bootstrap over documents (4,000 resamples): on new text SmolLM2-135M is worse than Laghu-Base by 0.022 (95% interval 0.020–0.024) and Falcon-H1-Tiny-90M-Base by 0.060 (0.057–0.062); Gargi-Base is better by 0.005 (0.004–0.006). On web text Laghu-Base and SmolLM2-135M are level.
The web and reasoning sets are held-out slices of our own data lineage, which favours our models; the new-text set is the clean comparison.
Commonsense benchmarks
On five zero-shot commonsense benchmarks Laghu-Base averages 49.9, against SmolLM2-135M’s 51.8. On the 5-task average, Laghu-Base is 5th of the 19 models up to 200M parameters that we measured on 19 October 2026; newer models are not in that set.
| Model | Params | ARC-E | ARC-C | HellaSwag | PIQA | WinoGrande | 5-task avg | MMLU | GSM8K 5-shot |
|---|---|---|---|---|---|---|---|---|---|
| Laghu-Base | 152M | 60.6 | 30.1 | 40.9 | 65.7 | 52.2 | 49.9 | 25.3 | 4.2 |
| GPT-X3-150M | 149M | 63.0 | 31.4 | 45.9 | 71.3 | 53.6 | 53.0 | 24.6 | 4.2 |
| SmolLM2-135M | 135M | 64.5 | 30.0 | 43.0 | 68.3 | 53.0 | 51.8 | 24.5 | 2.0 |
| Falcon-H1-Tiny-90M-Base | 91M | 54.3 | 28.5 | 37.7 | 64.8 | 50.8 | 47.2 | 32.4 | 2.7 |
| Gargi-Base (ours) | 384M | 63.0 | 32.5 | 41.5 | 66.9 | 54.5 | 51.7 | 25.3 | 5.7 |
lm-evaluation-harness 0.4.13, bf16, zero-shot (GSM8K 5-shot), with each model’s start token; measured by us on 19 October 2026. These benchmarks sit close to chance at this size, which is why we also measure bits per byte.
Long inputs: up to 16K tokens
After pretraining on 2,048-token pieces, Laghu read about a billion more tokens of long books, papers and documents at 32,768 tokens. A 5-digit code hidden in a long input is then found 100%, 100%, 99% and 96% of the time at 4K, 8K, 12K and 16K tokens, and never at 24K or 32K. So we claim 16K, not 32K. Before the stretch, the base model failed from 4K.

Good fits, and where it falls short
Good fits
- Research on small language models: training dynamics, fine-tuning, evaluation and distillation, starting from any surviving checkpoint.
- Reproducing a full training run on a small budget, with the exact code, recipe and data rebuild scripts.
- Teaching how language models are made, with every stage and every failure documented.
- On-device experiments where wrong answers are acceptable.
Where it falls short
- Maths: 7.9% on GSM8K with thinking on, and the arithmetic inside its thinking is often wrong. Falcon-H1-Tiny-90M-Instruct scores 23.3% and our Gargi 35.6%.
- Following instructions: IFEval prompt-level strict 26.1, against Falcon-H1-Tiny-90M-Instruct’s 60.8. Thinking on makes it worse (17.7).
- Behind Falcon-H1-Tiny-90M-Instruct on all three of our pre-registered chat tests. Falcon is smaller (91M) but used about 12× more training compute (800B tokens and a preference-tuning stage, as published by TII; the compute ratio is our estimate).
- Loops: 8.3% of greedy replies repeat until the length limit with thinking off, 12.0% with thinking on. The shipped sampling settings bring this to 1.2–1.9%.
- Long context: recall works up to 16K tokens and fails beyond (0% at 24K and 32K).
- Knowledge: a 152M model knows little and states wrong facts confidently; open questions often get incoherent answers.
- Thinking mode helps maths a little (GSM8K 4.8% → 8.0%) but lowers instruction following and multi-turn (41.7% → 32.6%).
- Light safety training: it can produce wrong, biased or harmful text, and it is not suitable for advice or decisions that matter. English only. The base models have no safety tuning.
What did not work
We publish the failures with the model, because they are as useful to the next person as the result.
- The release test failed. Before measuring, we wrote down three chat tests and three rivals, and set the bar: beat every rival in all three. Laghu won 0 of 3, because Falcon-H1-Tiny-90M-Instruct is ahead in each. We release it as a research release, with no result changed.
- Reinforcement learning made maths no better (8.6% → 8.2% against a bar of 11.6%) and loops worse, so the released model does not use it.
- The fine-tuning validation split leaked: about 37% of the eligible validation conversations had a near-copy in training. The pick used 200 separate leak-free conversations instead.
- A storage clean-up on 21 October 2026 deleted the pretraining checkpoints saved every 2,000 steps (steps 2,000–74,000). Our mistake; only the late checkpoints survive and are published.
- The run came in below projection: 0.921 bits per byte on new text after the 32K stretch, against 0.900–0.912 projected.
How it was made, and what it cost
- 1
Gather text
52.6 billion tokens from 14 public, openly licensed sources: educational web pages, rewritten web text, maths, Wikipedia, synthetic reasoning and chat text, and permissively licensed code. Documents that overlapped 10 test sets were removed.
A 32-vCPU cloud machine, about 3.7 hours
- 2
Pretrain
The model reads the text and learns to predict what comes next: 40.0 billion token positions, about 70 billion tokens read in all.
8× A100 80GB, 13.2 hours, $146.26
- 3
Stretch to long inputs
996 million tokens of long books, papers and documents at a 32,768-token context, so it can use up to 16K tokens.
1 GPU (RTX PRO 6000), about 4 hours
- 4
Teach it to chat
41,467 example conversations (34.5% multi-turn), shown twice. Two passes were chosen by a rule written before measuring.
1 GPU (Colab)
- 5
Reinforcement learning
One attempt failed its test, so the released model does not use it.
1 GPU

| Main pretraining run: 8× A100 80GB, 13.2 hours at $11.04 an hour, including a failed first start (about $1.90) | $146.26 |
|---|---|
| Data build, data-mix tests and dry runs (Runpod, 13 machines) | $36.01 |
| Cloud smoke tests (2) | $1.43 |
| DeepSeek API: fine-tuning data $9.49, fine-tuning pick judge $0.07, chat-quality judge $0.45 | $10.01 |
| X search for research | $0.03 |
| Total | About $194 |
The 32K stretch, fine-tuning, reinforcement learning and evaluations ran on about 60 Colab compute units included in a subscription. Money that produced no kept result was $5.05, 2.6% of the total.
The name
Laghu
लघु
Laghu (लघु) is Sanskrit for “small, light”.
A small model, with everything it took to make it.
The model
- Parameters
- 151.8M (tied input and output embeddings counted once)
- Layout
- Gemma 4 text architecture: 28 layers, width 640, 10 query and 2 key-value heads; three sliding-window layers (512 tokens) then one global layer, repeated
- Initialisation
- Random weights; trained from scratch, with our own 32,768-token tokenizer (shared with Gargi)
- Training
- 40.0B token positions of pretraining at 2K (about 70B tokens read), a 1B-token stretch at 32K, then fine-tuning on 41,467 conversations
- Context
- 16K tokens for use (stretched at 32K, but recall fails beyond about 16K)
- Modes
- Thinking on (a thought block before the answer) or off. We recommend off, except for short arithmetic
- Prompt format
- Gemma 4 chat format; sampling defaults temperature 0.7, top-p 0.95, top-k 64
- Licence
- Apache-2.0 for weights and code (Copyright 2026 Udgam Labs LLP); nanochat-derived files keep their MIT notice; training data keeps each source’s licence
How to run it
With transformers, in Python. Use the shipped sampling settings: greedy decoding loops more. Decode with special tokens kept, so the thinking and the answer can be told apart.
pip install "transformers>=5.18" torch
from transformers import AutoTokenizer, AutoModelForCausalLM
tok = AutoTokenizer.from_pretrained("udgamlabs/Laghu")
model = AutoModelForCausalLM.from_pretrained("udgamlabs/Laghu")
messages = [{"role": "user", "content": "Write a short poem about the sea."}]
inputs = tok.apply_chat_template(messages, add_generation_prompt=True,
enable_thinking=False, # True for short arithmetic
return_tensors="pt", return_dict=True)
out = model.generate(**inputs, max_new_tokens=512, do_sample=True,
temperature=0.7, top_p=0.95, top_k=64)
text = tok.decode(out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=False)
thinking, _, answer = text.rpartition("<channel|>")
print(answer.replace("<turn|>", "").strip())With Ollama, LM Studio, llama.cpp or MLX. These apps turn thinking on by default; the commands below turn it off for normal chat.
# Ollama
ollama run hf.co/udgamlabs/Laghu-GGUF:Q8_0 --think=false
# LM Studio: search for udgamlabs/Laghu-GGUF in the app and download Q8_0
# (API: send "reasoning_effort": "none" to turn thinking off)
# llama.cpp: an OpenAI-compatible server on localhost:8080, 16K-token context
llama-server -hf udgamlabs/Laghu-GGUF:Q8_0 --jinja --reasoning off -c 16384
# MLX on Apple silicon
pip install mlx-lm
mlx_lm.generate --model udgamlabs/Laghu-MLX --prompt "Who are you?" \
--chat-template-config '{"enable_thinking": false}'Everything is open
- Laghu
The chat model (fine-tuned, 2 passes), safetensors
- Laghu-Base
End of pretraining (step 76,294), EMA and raw weights, 2K context
- Laghu-Base-32K
After the 32K stretch (step 1,900), where fine-tuning started
- Laghu-Checkpoints
Raw training states with optimiser (steps 76,000 and 76,294; 32K steps 1,750 and 1,900), fine-tuning after 1, 2 and 3 passes, the failed RL run
- Laghu-GGUF
Builds for llama.cpp, Ollama and LM Studio
- Laghu-MLX
Build for Apple silicon (MLX)
- laghu-sft (dataset)
The 41,467 fine-tuning conversations, with source, generator and licence on every row
- laghu-evals (dataset)
Per-item evaluation outputs (scores only where a model’s licence asks for that), judge verdicts and validation sets
- GitHub: udgamlabs/laghu
Data builders, training, fine-tuning, RL and evaluation code, the pre-registration, and data rebuild scripts
- Technical report
The full recipe, every evaluation setting, the failures and the cost, with a PDF
Weights and our code are released under Apache-2.0 (Copyright 2026 Udgam Labs LLP); files from nanochat keep their MIT notice, and the chat template is Google’s Gemma 4 template (Apache-2.0). Training data keeps each source’s licence; the repository lists every source, its licence and the credit it asks for. The pretraining data ships as rebuild scripts. The checkpoints saved every 2,000 pretraining steps were lost in a storage clean-up, so only the late checkpoints are published.