UDGAM LABS · Language model · 152M parameters, fully open

Laghu

Laghu is a 152M-parameter English chat model trained from scratch by Udgam Labs for $146 of pretraining compute. It thinks before it answers (on/off), holds multi-turn conversations and chats, in 163 MB that runs in your browser. It is level with SmolLM2-135M-Instruct on chat quality and multi-turn conversation, ahead of it on maths with thinking, and level with our own 384M model Gargi on chat quality and multi-turn at 40% of the size. Its base model predicts new text (published September-October 2026) better than SmolLM2-135M after reading about 28 times fewer tokens (0.919 vs 0.941 bits per byte). Falcon-H1-Tiny-90M-Instruct, trained with about 12 times our 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. It is a fully open research release: weights, surviving checkpoints, code, the full recipe, evaluation outputs item by item, failures and cost.

Laghu (लघु) is Sanskrit for "small, light".

Run it

Thinking is off by default in transformers and on by default in Ollama, LM Studio, llama.cpp and the MLX server. It helps a little on short arithmetic and hurts most other tasks, so for normal chat turn it off: Ollama --think=false (or /set nothink in a chat), LM Studio API "reasoning_effort": "none", llama.cpp --reasoning off, MLX server --chat-template-args '{"enable_thinking":false}'. On a Mac mini (Apple M6) Laghu generates about 330 tokens per second in llama.cpp and 456 in MLX, and llama-server needs about 154 MiB of memory at a 4K context. The code is on GitHub.

transformers (5.18 or newer)

from transformers import AutoTokenizer, AutoModelForCausalLM

tok = AutoTokenizer.from_pretrained("udgamlabs/Laghu")
model = AutoModelForCausalLM.from_pretrained("udgamlabs/Laghu")

messages = [{"role": "user", "content": "A pen costs 12 rupees. How much do 7 pens cost?"}]
inputs = tok.apply_chat_template(messages, add_generation_prompt=True, enable_thinking=True,
                                 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)
answer = text.rpartition("<channel|>")[2]               # the answer follows the thinking block, if there is one
print(answer.replace("<turn|>", "").strip())

enable_thinking=False (the default) answers directly. Decode with skip_special_tokens=False and take the text after the last <channel|> as above: with skip_special_tokens=True the thinking text stays in front of the answer.

Sampling defaults (in generation_config.json): temperature 0.7, top-p 0.95, top-k 64. Greedy decoding loops more (see below).

Results

Measured by us on 2026-10-19 with one harness for every model (vLLM, bf16, greedy, the same items), as fixed in our pre-registration before Laghu was measured.

After a Holm correction over the nine comparisons, Laghu is ahead of SmolLM2-135M-Instruct and MobileLLM-R1.5 on maths and of MobileLLM-R1.5 on multi-turn, and level with SmolLM2-135M-Instruct on multi-turn and chat quality. Falcon-H1-Tiny-90M-Instruct, trained with about 12 times our compute and a preference-tuning stage, is ahead in all three categories. We fixed these categories, rivals and statistics in advance and publish every result as measured.

MobileLLM-R1.5-140M results are reported for noncommercial research under the FAIR Noncommercial Research License; we acknowledge Meta's materials.

Against our own models: chat quality vs Gargi (384M) 45.9% win rate, p = 0.06 (no significant difference); multi-turn 41.7% vs Gargi 49.3% (p = 0.12) and vs Udgam-384M-Chat 40.3% (p = 0.89).

Other measurements (reported, not claimed):

Every number with confidence intervals, the other 11 models we measured, and the per-item outputs of every model are in the technical report, on GitHub and in udgamlabs/laghu-evals.

Where it falls short

• Maths: 7.9% on GSM8K with thinking. The thinking is often wrong even when the answer is right. Example (greedy): for "A pen costs 12 rupees. How much do 7 pens cost?" it thinks "Convert the price to dollars: 12 ÷ 100 = 0.12 rupees per pen. Multiply by 7 pens: 0.12 × 7 = 0.84 rupees" and then answers "7 pens cost 84 rupees."
• Instructions: IFEval 26.1, far below Falcon-H1-Tiny-90M-Instruct (60.8). Thinking on makes it worse (17.7).
• Knowledge: a 152M model knows little and states wrong facts confidently. Do not rely on it for facts.
• Loops: with greedy decoding 8.3% of replies repeat until the length limit (12.0% with thinking on). Use the shipped sampling settings (1-2%).
• Long context: use up to 16K tokens. A hidden 5-digit code is found 96% of the time at 16K and never at 24K or 32K.
• Thinking mode helps maths a little (GSM8K 4.8% → 8.0%) but lowers multi-turn (41.7% → 32.6%) and IFEval.
• Compute gap: Falcon-H1-Tiny-90M-Instruct, which beats it everywhere we measured, trained on 800B tokens with a preference-tuning stage, about 12× Laghu's training compute (from TII's published description; our estimate).

How it was trained

Training compute ≈ 3.6 × 10¹⁹ FLOPs (6 × parameters × token positions). All-in cash cost about $194, including data generation, test runs and the judge. The training data was decontaminated against the evaluation sets (13-gram). Reinforcement learning (GRPO with distillation from Gargi) was tried and failed its gate, so this is the SFT model. Full recipe, data sources and licences, and every failure: technical report and GitHub.

Checkpoints: Laghu-Base (end of pretraining), Laghu-Base-32K (start of SFT) and Laghu-Checkpoints (raw training states with optimiser, SFT 1/2/3 passes, the failed RL run). The checkpoints saved every 2,000 pretraining steps were deleted by a storage clean-up on 2026-10-21, our mistake; only the late states survive.

Intended use and limitations

Research on small language models: training dynamics, fine-tuning, evaluation, distillation, on-device experiments, and teaching. It is not suitable for factual answers, advice (medical, legal, financial) or any decision that matters. It was trained on English only. Its safety training is light; it can produce wrong, biased or harmful text.

Licence

Apache-2.0. Copyright 2026 Udgam Labs LLP. The chat template is Google's Gemma 4 template (Apache-2.0). Training-data credits and licences: DATA_LICENSES.

Citation

@misc{udgamlabs2026laghu,
  title  = {Laghu: a fully open 152M chat model trained from scratch},
  author = {Prasad, Jitesh K},
  year   = {2026},
  howpublished = {Udgam Labs},
  url    = {https://huggingface.co/udgamlabs/Laghu}
}

---

About Udgam Labs. Udgam Labs is an independent AI research lab. We work from first principles: before we build, we understand why things work, whether we are training a model, fine-tuning one or applying AI to a new problem. Udgam (उद्गम) is Sanskrit for origin. udgamlabs.com