Models · Public release · 17 October 2026

Gargi

Close to Qwen2.5-0.5B on reasoning benchmarks, from about 1,000× less data.

A 384M-parameter English language model trained from scratch on about 17 billion tokens. It thinks step by step on maths problems, reads up to about 16,000 tokens, and runs comfortably on a laptop.

Try it now · free, no login

Ask Gargi a question. Read how it thinks.

Gargi

Ask a question, or pick an example. On maths problems Gargi thinks step by step first; open “Thinking” above a reply to read its working.

Try one of these

For maths, end the question with “Solve it step by step, then give the final answer on the last line as: Final answer: <number>”. The maths examples do this for you. Thinking shows up mainly on maths problems.

Gargi is a 384M-parameter research model and is often wrong on facts, arithmetic and code: double-check anything important. Please don't share personal information. Gargi itself is not safety-tuned, so a filter in front of it declines clearly harmful requests. Free and without login, with a fair-use limit per visitor. It runs on our own machine, so it may be slow or offline at times.

The result

Within 2 points on reasoning. Clearly behind on knowledge.

On the same evaluation harness, Gargi's base model comes within 2 points of Qwen2.5-0.5B on ARC-Easy, ARC-Challenge and WinoGrande (62.8 vs 64.7, 32.3 vs 32.4, 54.6 vs 56.1), although Qwen2.5-0.5B was trained on ~18 trillion tokens and Gargi on ~17 billion. Knowledge-heavy and everyday-commonsense benchmarks (MMLU, HellaSwag, PIQA) still scale with data, and there Gargi is clearly behind.

Try it free in your browser Weights on Hugging Face GGUF for Ollama & llama.cpp MLX for Apple silicon Technical report

About 1,000× less training data

Gargi read about 17 billion tokens of openly licensed and public-domain text, plus synthetic text from open models. Comparable open models are trained on trillions of tokens. On reasoning-style multiple choice, that gap barely shows.

Training tokens · one square ≈ 17 billion

Gargi · ≈17B

Qwen2.5-0.5B · ~18T (as published by its authors)

Base models · same harness · accuracy %

ARC-Easy: Gargi-Base 62.8
Qwen2.5-0.5B 64.7
ARC-Challenge: Gargi-Base 32.3
Qwen2.5-0.5B 32.4
WinoGrande: Gargi-Base 54.6
Qwen2.5-0.5B 56.1

lm-evaluation-harness, 0-shot, greedy. Qwen2.5-0.5B's token count is as published by its authors.

How it compares

Gargi trades breadth for efficiency. On reasoning-style multiple choice (ARC, WinoGrande) it is close to models trained on hundreds to thousands of times more data; on knowledge-heavy and everyday-commonsense benchmarks (MMLU, HellaSwag, PIQA) it is clearly behind.

Base models, accuracy %, measured by us on one harness
Model	Params	Training tokens*	MMLU	ARC-E	ARC-C	HellaSwag	WinoGrande	PIQA
Gargi-Base	384M	~0.017T	25.5	62.8	32.3	41.5	54.6	66.8
Qwen2.5-0.5B	494M	~18T	47.3	64.7	32.4	52.1	56.1	70.0
SmolLM2-360M	360M	~4T	25.6	70.2	38.3	56.3	59.0	71.5
Granite-4.0-350M (base)	352M	–	32.0	65.4	33.7	52.0	56.0	70.7
Gemma-3-270M (pt)	268M	~6T	26.1	58.8	28.2	41.3	53.4	68.1

lm-evaluation-harness, 0-shot, greedy, with each model's start token. *Training-token counts for other models are as published by their authors.

It thinks before it answers

The chat model can think step by step before it answers, or answer straight away. It writes its thoughts mainly on maths problems, and thinking lifts its maths score.

GSM8K, thinking on: 36.0; Chat template, 0-shot, greedy
GSM8K, thinking off: 32.9; Same settings, no thinking
GSM8K 5-shot: 19.8; lm-eval, no chat template

Chat model on the other benchmarks: MMLU 24.9 · ARC-E 62.2 · ARC-C 31.0 · HellaSwag 42.0 · WinoGrande 55.2 · PIQA 66.4.

Not a maths specialist

Newer small models trained on far more data score higher on maths. Reported elsewhere, with varying settings: Qwen3-0.6B scores 79.2 on GSM8K with thinking (0-shot pass@1, as reported in the MobileLLM-R1.5 model card); MobileLLM-R1.5-360M 52.8 and Granite-4.0-H-350M 39.3 (8-shot), as published by their authors. Gargi scores 36.0.

For maths, end the question with “Solve it step by step, then give the final answer on the last line as: Final answer: <number>”. It gives the most reliable answers.

Long documents: reliable up to about 16K tokens

A 5-digit code is hidden early in a long document of real text and asked for at the end; 30 trials per length. Gargi was trained at 32K tokens and finds the code every time at 8K, 93% of the time at 16K and 90% at 20K. Beyond that it falls away, while several other small models hold to 32K. Use Gargi with inputs up to about 16K tokens.

Needle in a haystack, % of 30 trials found
Model	Params	8K	16K	20K	24K	32K
Gargi	384M	100	93	90	13	0
Qwen3-0.6B	600M	100	100	100	100	100
Hunyuan-0.5B-Instruct	500M	100	100	100	100	100
Falcon-H1-Tiny-R-0.6B	600M	100	97	100	100	97
Granite-4.0-H-350M	350M	100	100	100	100	100
ERNIE-4.5-0.3B	300M	100	100	100	100	100
Gemma-3-270M-it	270M	100	100	100	100	63
LFM2.5-350M	350M	90	0	0	0	0
SmolLM2-360M-Instruct	360M	60	n/a	n/a	n/a	n/a

Each model gets its own start token; lengths beyond a model's declared context are marked n/a.

All rows were measured by us on the same harness and settings (lm-evaluation-harness, 0-shot, GSM8K 5-shot, greedy, with each model's start token), unless marked as published by the model's authors.

What it is good for, and what it is not

Good fits

Learning and experimenting with small models.
Offline, on-device chat and step-by-step maths explanations, where mistakes are acceptable.
Reading and answering questions about documents up to about 16K tokens.

Limitations

Often wrong on facts, arithmetic and code; double-check anything important.
Limited world knowledge: MMLU is near chance.
Behind newer small models on maths.
Reliable recall only up to about 16–20K tokens, although it accepts 32K.
English only.
Not safety-hardened (see below).

Safety

Gargi has not been safety-tuned beyond a small set of refusal examples. In our tests it may follow harmful requests (for example, it gave steps when asked how to break into a neighbour's house), and it sometimes lists other assistants it is not (“I'm not ChatGPT, Gemini, …”) without being asked.

Treat it as a research and hobby model.
Put a moderation layer in front of any deployment that people use. The try box above has one.
Do not use it for medical, legal, financial or safety-critical advice.

The name

Gargi

Gargi Vachaknavi

Gargi is named after Gargi Vachaknavi, the Vedic philosopher remembered for asking the hardest questions.

A small model that thinks before it answers.

The model

Parameters: 384M · Gemma 4-style decoder, sliding-window + global attention
Initialisation: Random weights; trained from scratch
Training data: ≈17B tokens read in total: openly licensed or public-domain text, plus synthetic text from open models
Context: Trained at 32K tokens; reliable recall up to ~16K (100% at 8K, 93% at 16K, 90% at 20K)
Modes: Thinking on (step-by-step reasoning before the answer) or off
Prompt format: Gemma 4 chat format; the included chat template handles thinking on and off
Language: English
Licence: Apache-2.0 (weights and tokenizer)

How to run it

It runs comfortably on a laptop or phone-class device. Use the Q8_0 GGUF unless memory is tight.

# Ollama (/set think for step-by-step thinking)
ollama run hf.co/udgamlabs/Gargi-GGUF:Q8_0

# llama.cpp, with a 16K-token context
llama-cli -hf udgamlabs/Gargi-GGUF:Q8_0 -c 16384

# MLX on Apple silicon
pip install mlx-lm
mlx_lm.chat --model udgamlabs/Gargi-MLX

Quantization · GSM8K with thinking, first 200 problems
Build	Size	GSM8K	Same as f16
f16	770 MB	39.0	–
Q8_0 (recommended)	410 MB	37.5	96.5%
Q4_K_M	238 MB	32.0	87%

Greedy, via Ollama. Q8_0 matches f16 closely; Q4_K_M loses a few points (each score is ±3.4 points at this sample size).

Weights and builds

Gargi
Chat model: weights and model card
Gargi-Base
Pretrained base model; continues text
Gargi-GGUF
Q8_0, Q4_K_M and f16 for Ollama and llama.cpp
Gargi-MLX
Apple silicon (bf16)
Gargi-MLX-4bit
Apple silicon (4-bit)
GitHub: UdgamLabs/gargi
Docs, runnable examples and checksums

Weights and tokenizer are released under Apache-2.0. The chat template is the Gemma 4 template (Apache-2.0). Gargi was trained on openly licensed and public-domain text and synthetic text from openly licensed models; the model card lists every source and its licence.