Papers
Topics
Authors
Recent
Search
2000 character limit reached

Agaram 2.5B: The First Tamil-First Language Model Trained from Scratch with Tool Calling. A Playbook for Under-Represented Languages

Published 13 Oct 2026 in cs.CL, cs.AI, and cs.LG | (2610.18420v1)

Abstract: We trained Agaram 2.5B, a 2.5-billion-parameter Tamil-English LLM, from scratch on about 50 billion tokens (58% Tamil, the rest English, math, code and parallel text) on one node of eight H100 GPUs in about six days, with a new tokenizer that, unlike our first model's, keeps line breaks. Supervised fine-tuning on 134,428 conversations, whose replies an open-weight teacher model wrote, and three short targeted rounds turned it into a chat model that answers in Tamil script, romanized Tamil (Tanglish) and English and can call tools: on 25 tool prompts whose schemas appear in training it picks the right tool 23 times and gives exactly the expected arguments 13 times. The released model translates better than Sarvam-1, a 2B Indic base model, in all six FLORES and IN22 directions (FLORES chrF 54.3 into Tamil and 55.2 into English, against 49.2 and 44.2), and nearly doubles its base model on native-Tamil IndicIFEval (19.3% from 10.0%). It is weak on knowledge: reading-comprehension and knowledge benchmarks sit near chance, and on 50 held-out everyday questions written by one native speaker, one LLM judge rated 46% of its replies usable (22-24 of 50 over three passes; 95% interval for 23 of 50, 33-60%), with nearly every failure a wrong fact. Our two further SFT experiments changed answer format but not the knowledge measures. We also describe our first model, Agaram 1.5B, whose failures shaped the choices here; how the judge's scores varied between passes on identical replies; and, item by item, what the targeted rounds trained against and where frontier-model text entered the data. The project ran on compute credits and our own funds, about USD 13,300 across both models; the weights are released (licence to be announced after legal review), with GGUF files for llama.cpp, at https://huggingface.co/murai-labs/agaram-2.5b-instruct; code at https://github.com/Murai-Labs/Agaram2.5b

Summary

  • The paper details the successful creation of Agaram 2.5B, a 2.53-billion-parameter Tamil–English language model trained from scratch, optimized for Tamil language tasks, notably achieving 55.1 chrF on English-to-Tamil translation.
  • Agaram 2.5B addresses data and tokenization challenges that hinder under-represented languages, employing a custom tokenizer that reduces average Tamil tokenization to 1.55 tokens per word, compared with 9.44 tokens in Qwen2.5.
  • The methodology includes novel checkpoints and rigorous operational practices that significantly alleviate complexity and resource consumption during both training and fine-tuning phases, achieving a 94,700 tokens per second throughput during pretraining.

Motivation and contribution

Agaram 2.5B presents a complete development account of a 2.53-billion-parameter Tamil–English LLM trained from scratch, with Tamil as the majority pretraining language and tool calling as an explicit post-training capability (2610.18420). The paper’s central claim is not that a small model can match large multilingual systems generally, but that a carefully engineered, language-specific pipeline can produce a useful Tamil-oriented model under a constrained budget. The resulting system is technically competent in translation, formatting, script control, and schema-conditioned tool invocation, while remaining substantially deficient in factual knowledge, reading comprehension, safety robustness, and general conversational reliability.

The work is motivated by a concrete tokenizer and data imbalance problem. On the authors’ samples, Qwen2.5 tokenizes Tamil words into an average of 9.44 tokens, compared with 1.35 tokens for English words. Agaram’s tokenizer reduces Tamil prose to 1.55 tokens per word. This difference is important for a small model because token inefficiency consumes context and compute without increasing linguistic coverage. The authors therefore investigate whether Tamil-first pretraining, rather than adaptation of an English-centric checkpoint, can provide a better quality–cost trade-off for an under-represented language.

The paper also functions as a reproducibility report. It documents two training attempts, reports failures rather than only successful configurations, describes data and contamination checks, and provides operational details for completing a single large training run on rented hardware. The resulting model, tokenizer, base checkpoint, instruction-tuned checkpoint, GGUF conversions, and associated tooling are released, although the full training corpus and several evaluation artifacts are not.

From the first model to Agaram 2.5B

Agaram 2.5B was preceded by a 1.5-billion-parameter model whose failures determined many of the second model’s design choices. The first model used a SentencePiece tokenizer whose normalization erased all line breaks and indentation. As a result, the model did not observe newlines during pretraining, never learned the chat stop token in its natural training context, and performed poorly on lists, verse, code, and conversational termination. Its continued-pretraining data also lacked document separators, allowing attention to cross document boundaries and causing free-form generation to continue into memorized instructional material.

The first model’s post-training results were particularly poor. On a 100-prompt open-chat evaluation, it produced only 2 usable responses. Adding approximately 14,000 native-Tamil conversations increased this result only to 6–8 responses, leading the authors to conclude that the base model rather than the SFT data was the primary bottleneck. This is a useful negative result: high-quality instruction data cannot reliably compensate for a weak or structurally damaged pretrained representation.

The authors also evaluated Mamba-2, Mamba-3, and Gated DeltaNet hybrids against dense Transformers at approximately 91 million parameters. At 25,000 steps, the Mamba-2 hybrid was marginally better on held-out Tamil loss, 6.891±0.0116.891 \pm 0.011 versus 6.901±0.0066.901 \pm 0.006. At 75,000 steps, however, the dense Transformer was clearly superior: 7.003±0.0557.003 \pm 0.055 versus 7.278±0.0787.278 \pm 0.078, despite the hybrid having lower training loss. Mamba-3 was unstable across seeds, with a held-out-loss standard deviation approximately ten times that of the dense model. The authors consequently selected a conventional dense Transformer, while explicitly limiting the conclusion to the tested scale and training conditions.

Data, tokenizer, and model design

The final tokenizer is a 64,000-token byte-level BPE with no normalizer. It preserves line breaks, indentation, and arbitrary byte sequences, and its pre-tokenizer treats Unicode combining marks and zero-width joiners as part of words. This modification is particularly relevant to Tamil, whose vowel signs are combining marks. The tokenizer exactly round-trips the evaluated text, unlike the first model’s tokenizer, which failed on multiline material.

The tokenizer’s advantages are uneven. It matches the first tokenizer on Tamil prose at 1.55 tokens per word, but improves Tanglish from 2.95 to 1.95 tokens per word, code from 4.54 to 3.54, tool-call JSON from 3.46 to 2.52, and plain-text chat from 3.14 to 2.19. It also reduces Tamil-script cost relative to English-oriented tokenization. However, 14.3% of Tamil token boundaries fall inside grapheme clusters, compared with 4.7% for the previous tokenizer, and verse becomes more expensive at 2.29 tokens per word. The paper does not measure the modeling consequences of these grapheme-internal boundaries, leaving tokenizer quality only partially characterized.

The pretraining corpus contains 39.39 billion unique tokens expanded to approximately 50 billion training tokens through repetition. Tamil accounts for 58.2%, English for 19.8%, mathematics for 10%, code for 7%, parallel text for 2%, and instruction data for 3%. After deduplication, the available native Tamil material amounted to only 16–19 billion tokens, so some Tamil sources were repeated up to four times. The corpus combines web crawls, books, OCR-derived text, Project Madurai, Wikipedia, parallel corpora, mathematics, code, and instruction-shaped material.

The final 6.5-billion-token decay stage changes both the learning rate and the data distribution. Broad web sources are downweighted while curated Tamil, educational English, mathematics, and instruction sources are upweighted. This produces substantial improvements in held-out Tamil bits per character, especially for literary EPUB text, which improves by 12.8%. The interpretation is qualified: other passages from many of those books were present in the training data, so the literary result measures generalization within partly observed books rather than generalization to unseen literature.

Architecturally, Agaram 2.5B is a dense decoder-only Transformer with 28 layers, hidden size 2,304, 36 attention heads, SwiGLU feed-forward layers of width 9,216, RMSNorm, rotary embeddings with a 500,000 base, tied input and output embeddings, and an 8,192-token context window. Training uses bf16, Adam with weight decay, gradient clipping, and document-local attention masks. Documents are packed into sequences, but attention does not cross end-of-text boundaries and rotary positions restart for each document. This directly addresses the first model’s contamination of document contexts.

Training scale and operational methodology

Pretraining was conducted on one node containing eight H100 GPUs. The stable stage processed 43.5 billion tokens at a 4,096-token context, followed by a 6.5-billion-token decay stage at an 8,192-token context. The stable stage took 130.1 hours and achieved median throughput of 94,700 tokens per second; the decay stage took 17.6 hours at 107,500 tokens per second. The training run completed without restarts, numerical failures, or throughput collapses.

The operational design is one of the paper’s more practically valuable contributions. Checkpoints were copied off-node every two hours, archived independently, verified with hashes, and protected by a termination guard that prevented cloud-instance shutdown until the final checkpoint and logs had been copied. This procedure was explicitly derived from the first model’s lost final checkpoint. The production pretraining run cost approximately USD 4,765 in rented compute, below a USD 5,000 cap.

The authors report that a power law fitted using only steps 3,000–30,000 forecast all later stable-stage validation losses to within 0.004. This suggests that inexpensive early-run diagnostics can provide useful budget and stopping information, although the claim is based on one training trajectory and therefore should not be interpreted as a validated scaling law.

Translation performance and benchmark profile

Translation is the strongest capability of the base model. Agaram 2.5B outperforms Sarvam-1, a roughly 2-billion-parameter multilingual Indic model, in all six reported FLORES and IN22 directions. On FLORES, Agaram achieves 55.1 chrF for English-to-Tamil and 55.5 for Tamil-to-English, compared with Sarvam-1’s 49.2 and 44.2. On IN22-Conv it scores 40.8 and 46.0 against 37.4 and 37.9; on IN22-Gen it scores 48.8 and 54.3 against 45.9 and 42.7.

These gains survive contamination filtering. Restricting translation evaluation to pairs whose Tamil and English sides have less than 5% overlap with the training pack changes Agaram’s scores by at most 1.14 chrF, and the model remains ahead of Sarvam-1 in every direction. This is an important qualification because portions of the English FLORES and IN22 material originate in Wikipedia-derived sources present in the training corpus.

The released chat model preserves nearly all of the base model’s translation performance. Its FLORES scores are 54.3 chrF for English-to-Tamil and 55.2 for Tamil-to-English, while IN22 results remain within approximately one point of the base checkpoint. The SFT process therefore improves conversational formatting and instruction following without materially sacrificing translation.

The benchmark profile is sharply asymmetric. Agaram reaches 99.0% on Tamil MultiBLiMP and 62.0% on XCOPA, approximately matching Sarvam-1 on commonsense and exceeding it on grammatical minimal pairs. In contrast, it performs near chance on knowledge and reading-comprehension tasks: 27.8 on Belebele-Tamil, 26.9 on INCLUDE-Tamil, and 25.5 on MMLU-Tamil. Sarvam-1 obtains 58.3, 35.5, and 32.6 respectively. MILU performance is similar between the models, at approximately 29%.

The authors infer that the knowledge gap may reflect training volume: Sarvam-1 reports approximately 4 trillion training tokens, including 2 trillion high-quality Indic tokens, whereas Agaram uses 50 billion. This remains an inference rather than an experimentally isolated cause. Model scale, corpus composition, data quality, multilingual transfer, and pretraining duration are confounded.

Supervised fine-tuning and tool calling

The general SFT corpus contains 134,428 conversations, including Tamil script, Tanglish, English, multi-turn interactions, tool calls, translation, safety, crisis-support, and formatting data. Most assistant responses were generated by open-weight teacher models, primarily Gemma-4-31B, with loss applied only to assistant turns. The model was trained for three epochs, although almost all validation-loss improvement occurred during the first epoch.

SFT converts the base model into a substantially more usable conversational system in several narrow respects. The proportion of replies passing scripted formatting checks increases from 6–9% for the base model to approximately 88–95% after SFT. The proportion of replies stopping autonomously increases from 15% to nearly 100%. Native-Tamil IndicIFEval accuracy rises from 10.0% to 19.3% at the released checkpoint, while Qwen2.5-1.5B-Instruct scores 11.2% in the authors’ harness.

The translated IndicIFEval subset behaves differently. The base model scores 19.6%, falling to 15.3% after SFT. The paper identifies template exposure as a confound: Tamil versions of IFEval-like instruction templates entered the decay-stage corpus through SmolTalk-derived data. Consequently, the base-model score on the translated subset may overstate general instruction following. The native subset is the more defensible measure of SFT improvement.

Tool calling is a principal claimed capability. On 25 prompts whose tool schemas also appear in training, the released model selects the correct tool 23 times, or 92%, and produces exactly the expected arguments 13 times, or 52%. The general SFT checkpoint obtains 24 correct tools and 15 exact argument sets. These results demonstrate schema-conditioned invocation rather than robust tool use in open environments. The evaluation does not test unseen schemas, execution success, recovery from tool errors, or grounding in unreliable tool outputs.

The paper’s targeted SFT rounds address identity, crisis responses, harmful requests, tool-result handling, constraint memory, and multi-turn repair. They improve the specific probes used to construct them. For example, Tele-MANAS appears in 7 of 10 crisis-probe responses in the released model, and identity responses become more resistant to several false model-attribution claims. However, these probe results are not independent evaluations because the rounds were designed from failures on related prompts.

Factuality and conversational quality

The most consequential result concerns factual reliability. On a held-out set of 50 everyday questions written by one native speaker after the release checkpoint was selected, the model receives usable judgments on 23, 22, and 24 items across three passes, for a mean of 23.0 or 46%. The set contains Tanglish and Tamil-script questions, single-turn and two-turn interactions, and simple factual prompts concerning ordinary objects, explanations, and social interactions.

Nearly every failure is factual rather than stylistic. In one example, the model recommends the Undo key for erasing a pencil mark; in another, it answers that a pair contains 12 slippers. In the first evaluation pass, 26 of 27 unusable replies were marked factually wrong, while almost all still stopped correctly and used the requested script. Thus, high formatting accuracy substantially overestimates practical quality.

The targeted rounds do not produce a detectable improvement on this held-out set. The first SFT stage scores a mean of 21.0 out of 50, while the released model scores 22.3. Across item-level majority judgments, the released checkpoint wins seven items and loses six, yielding no evidence of a systematic difference. The authors correctly state that 50 prompts can detect only a relatively large effect; the result excludes neither modest gains nor domain-specific improvements.

Judge instability further limits the precision of the reported chat scores. On an earlier 100-prompt set, the same replies receive 57 usable judgments in one pass and 46 in a re-pass, with 13 verdicts changing. Later passes yield 49 and 52. The authors therefore report means and ranges rather than relying on a single LLM-judge run. This methodological caution is warranted, but it does not remove the underlying limitation: large-scale human evaluation of the released model is absent.

Limitations and open questions

The paper’s empirical claims are constrained by a one-run training design. Agaram 2.5B has no same-scale random-seed replication, systematic ablation of tokenizer choices, controlled comparison of corpus mixtures, or independent validation of the decay-stage effect. The Transformer-versus-state-space comparison is performed only at approximately 100 million parameters, so it does not establish that dense attention is optimal at the final scale.

The evaluation also has incomplete contamination coverage. XCOPA, HellaSwag, INCLUDE, and MultiBLiMP were not scanned against the training pack, and short evaluation items cannot be reliably assessed with the 13-token-window procedure. The authors disclose these gaps rather than treating the benchmark suite as uncontaminated.

Safety evidence is especially limited. There is no red-teaming campaign, no independent judge evaluation of safety training rows, and crisis data was reviewed by an AI reader rather than a human specialist. Despite 47 targeted refusal examples, the released model still responds affirmatively to a request for disabling office security logs, even though the technical instructions are incorrect. It also exhibits identity confabulation, over-refusal, inconsistent crisis behavior, and unverified grounding in off-topic tool results.

The release is not fully reproducible in the strict sense. Weights, tokenizer files, conversion scripts, and model cards are available, but the training corpus, source manifests, filtering rules, training code, evaluation prompts, tool schemas, judge rubric, responses, and verdicts are not. Licensing remains complicated by upstream dataset and OCR-tool terms, including material whose usage conditions may not be compatible with unrestricted redistribution. These issues affect the legal and scientific reproducibility of the release.

The principal open empirical question is whether the knowledge deficit is primarily caused by the 50-billion-token pretraining budget, insufficient high-quality Tamil data, model capacity, or corpus composition. The authors suspect that more pretraining would help, but the paper does not test this hypothesis. It also leaves open whether additional Tamil data would improve factuality without reducing translation and instruction-following performance, whether tool grounding can be made robust to irrelevant retrieval results, and whether grapheme-internal tokenizer boundaries measurably affect Tamil generation.

Conclusion

Agaram 2.5B demonstrates that a small team can train and release a Tamil-first model from scratch at moderate compute cost, provided that tokenizer design, corpus construction, document boundaries, checkpoint management, contamination analysis, and native-speaker evaluation are treated as first-class engineering problems (2610.18420). Its strongest results are in Tamil–English translation, grammatical discrimination, script-sensitive formatting, and tool selection on seen schemas. Its weaknesses are equally clear: near-chance knowledge performance, unreliable everyday factuality, limited safety robustness, unstable LLM-judge measurements, and incomplete evaluation independence.

The paper’s main contribution is therefore an empirical playbook with explicit failure analysis rather than a uniformly capable LLM. It establishes that Tamil-first training can yield strong language-specific behavior under a constrained budget, while also showing that post-training cannot substitute for broad factual competence acquired during pretraining.

Paper to Video (Beta)

No one has generated a video about this paper yet.

Whiteboard

No one has generated a whiteboard explanation for this paper yet.

Explain it Like I'm 14

1. What is this paper about?

This paper explains how the researchers built Agaram 2.5B, a computer program that understands and generates language.

Agaram was designed especially for Tamil, although it can also use English and Tanglish—Tamil written with English letters, such as typing Tamil sounds using the Roman alphabet.

The researchers wanted to answer an important question:

Can a relatively small LLM work well in Tamil if it is built for Tamil from the beginning, instead of being mainly designed for English?

They trained the model from the beginning using Tamil text, books, websites, translations, mathematics, computer code, and conversations.

2. What questions did the researchers investigate?

The researchers mainly wanted to find out:

  • Can a small model learn Tamil effectively when most of its training material is Tamil?
  • Does a special Tamil-friendly tokenizer help the model read Tamil more efficiently?
  • Can the model understand Tamil written in different forms, including Tamil script and Tanglish?
  • Can it translate between Tamil and English?
  • Can it answer questions, follow instructions, and use outside tools?
  • What are the model’s weaknesses?
  • Can a small research team train such a model with limited money and computer equipment?

The team also learned from an earlier model, Agaram 1.5B. That model performed poorly, so the researchers changed several parts of their method for Agaram 2.5B.

3. How was the research carried out?

Building a tokenizer

Before a LLM can read text, the text must be broken into small pieces called tokens. A token might be a whole word, part of a word, punctuation, or even a single character.

You can think of tokens like puzzle pieces. The model reads these pieces and tries to predict which piece should come next.

Many existing models break Tamil words into far too many pieces. For example, one Tamil word might become about nine pieces, while an English word might become only one or two. This makes Tamil more expensive and difficult for the model to process.

The researchers created a new tokenizer designed for Tamil, English, Tanglish, code, and chat. It used about 1.55 tokens per Tamil word, much fewer than the roughly 9.4 tokens per Tamil word used by one common tokenizer.

The new tokenizer also kept:

  • Line breaks
  • Spaces and indentation
  • Lists
  • Poems
  • Computer code
  • Tool instructions

This was important because the first model had accidentally removed line breaks. As a result, it struggled with lists, code, and knowing when a conversation ended.

Training the model

Agaram 2.5B has about 2.5 billion parameters. Parameters are adjustable numbers inside a model. They are a little like the connections in a brain: during training, the model changes them so it becomes better at predicting text.

The model was trained on about 50 billion tokens. Approximately:

  • 58% were Tamil
  • 20% were English
  • 10% were mathematics
  • 7% were computer code
  • The rest included translations and instruction examples

The training used eight H100 graphics cards, which are powerful computers often used for artificial intelligence. The main training took about six days.

The researchers also used books that had been scanned as images. They used OCR, or optical character recognition, to turn the images into digital text. Because OCR can make mistakes, they checked and cleaned some of the results.

Teaching the model to chat

After the main training, the researchers gave the model examples of conversations. This process is called supervised fine-tuning, or SFT.

Fine-tuning is like giving a student extra lessons after they have learned the basics. The model saw about 134,000 conversations involving:

  • Questions and explanations
  • Tamil and Tanglish conversations
  • Translation
  • Safety
  • Teaching
  • Tool use
  • Everyday help
  • Multi-step conversations

Some answers were written by other open LLMs and then used as examples for Agaram.

Teaching it to use tools

Agaram was also trained to call tools. A tool could be a calculator, search system, database, or another computer program.

For example, if a user asks for the weather, the model might need to call a weather tool rather than inventing an answer. The model must choose the correct tool and send the correct information to it.

The researchers tested this with 25 tool-related questions.

Testing the model

The researchers tested Agaram in several ways:

  • Tamil-to-English and English-to-Tamil translation
  • Reading comprehension
  • General knowledge
  • Multiple-choice questions
  • Grammar and language understanding
  • Tool calling
  • Everyday questions written by a native Tamil speaker

They compared Agaram with other models, especially Sarvam-1, a model that supports several Indian languages.

They also checked whether test questions had accidentally appeared in the training material. This is important because a model could seem clever simply because it had already seen the answers.

4. What did the researchers discover?

Translation was Agaram’s strongest skill

Agaram 2.5B translated better than Sarvam-1 in all six translation tests reported in the paper.

For example, on one test:

  • English to Tamil: Agaram scored 55.1, compared with Sarvam-1’s 49.2
  • Tamil to English: Agaram scored 55.5, compared with Sarvam-1’s 44.2

These scores used chrF, a method that compares the letters and character sequences in a model’s translation with a correct reference translation. This is useful for Tamil because small word endings can change a word’s meaning.

This result suggests that training with a large amount of Tamil text helped the model understand Tamil translation well.

It handled several forms of Tamil

The model could respond in:

  • Tamil script
  • Tanglish
  • English

This is valuable because many Tamil speakers use both Tamil letters and English letters when chatting online.

It could use tools reasonably well

In the tool test, Agaram chose the correct tool 23 out of 25 times.

However, it supplied exactly the expected arguments only 13 out of 25 times. In other words, it often knew which tool to use but was less reliable at filling in all the details correctly.

It improved at following Tamil instructions

On the native-Tamil IndicIFEval test, the model nearly doubled the score of its base version:

  • Earlier base model: 10.0%
  • Final model: 19.3%

This means the additional conversation training helped it follow certain instructions better.

Its knowledge and factual answering were weak

The model’s biggest weakness was general knowledge.

On reading-comprehension and knowledge tests, its results were often close to what would be expected from guessing. In a separate test, a judge examined 50 everyday questions written by a native speaker.

Only about 46% of the answers were judged usable. Most of the bad answers contained incorrect facts.

This is an important warning: a model may sound fluent in Tamil but still give wrong information.

Extra training did not solve the knowledge problem

The researchers tried more rounds of fine-tuning to improve the model. These changes sometimes altered the style or format of answers, but they did not noticeably improve its knowledge or factual accuracy.

This suggests that simply giving a model more conversation examples may not be enough to teach it reliable facts.

The first model taught the team important lessons

Agaram 1.5B was much less successful. It gave usable answers to only a small number of open-ended questions.

Its problems included:

  • A tokenizer that erased line breaks
  • Too little English, mathematics, code, and instruction data
  • Poor handling of document boundaries
  • Errors in scanned text
  • A lost final training checkpoint
  • Evaluation problems caused by test material appearing in training data

The researchers redesigned the process for Agaram 2.5B based on these failures.

5. Why are these results important?

This paper shows that a small team can build a LLM for an under-represented language such as Tamil without needing the enormous resources of the largest technology companies.

The work is important because many LLMs are much better at English than at languages such as Tamil. If people can only use advanced technology in English, Tamil-speaking students, families, and communities may receive fewer benefits from it.

Agaram demonstrates several useful ideas:

  • A tokenizer designed for a specific language can make training more efficient.
  • Training data should include the way people really write, including Tanglish.
  • Line breaks, punctuation, and document boundaries matter.
  • Translation ability can become strong even when general knowledge is still weak.
  • A model should be tested carefully instead of being judged only by how fluent it sounds.
  • Publicly releasing the model and the training methods can help other researchers improve it.

Conclusion: What could this research lead to?

Agaram 2.5B could help support future Tamil-language tools, such as:

  • Tamil chat assistants
  • Translation programs
  • Educational software
  • Writing and spelling support
  • Voice and text applications
  • Tools that work with Tamil books and documents

However, the model is not yet reliable enough to be trusted with important facts without checking its answers. It can produce natural-sounding language while still being wrong.

The main lesson is that language ability and factual knowledge are different skills. Agaram became fairly good at Tamil translation and basic tool use, but it still struggled to know whether its answers were true.

The researchers’ work provides a useful starting point. Future models could use their Tamil-focused tokenizer and training methods while adding better sources of trustworthy knowledge, stronger testing, and improved methods for checking facts.

Knowledge Gaps

Knowledge gaps, limitations, and open questions

  • Limited evaluation of factual knowledge: The model performs near chance on several reading-comprehension and knowledge benchmarks, but the paper does not identify which knowledge domains, temporal periods, or question types account for these failures.
  • Small and non-independent chat evaluation: Usability was assessed on only 50 everyday questions written by one native speaker, limiting conclusions about performance across Tamil dialects, regions, demographics, domains, and interaction styles.
  • Dependence on a single LLM judge: Chat quality relies heavily on one model-based judge whose scores varied substantially across repeated passes. Human evaluation with multiple independent Tamil-speaking annotators is still needed to establish validity and inter-rater reliability.
  • Unclear relationship between benchmark performance and real-world utility: Strong translation and grammar scores coexist with weak factual answering, but the paper does not determine whether standard Tamil benchmarks predict practical usefulness for users.
  • Insufficient comparison with strong contemporary baselines: Comparisons are mainly against Sarvam-1 and smaller models. The effects of model family, pretraining scale, multilingual coverage, instruction tuning, and parameter count are not isolated through matched baselines.
  • No controlled ablation of the Tamil-first design: The paper does not quantify how much of the performance gain comes from the Tamil-heavy corpus, tokenizer, training from scratch, data mixture, model architecture, or post-training choices.
  • Tokenizer effects are incompletely understood: Although the new tokenizer improves round-trip fidelity and reduces costs for some text types, the paper does not measure its effects on downstream generation quality, morphology, grapheme-boundary fragmentation, long-context reasoning, or user-facing latency.
  • No systematic comparison of tokenizer alternatives: The morphological tokenizer, alternative byte-level configurations, vocabulary sizes, and other Tamil-specific segmentation strategies were not evaluated at model scale.
  • Unresolved impact of grapheme-cluster splits: Approximately 14.3% of Tamil token boundaries fall inside grapheme clusters, but the consequences for spelling, pronunciation-related representations, generation errors, and linguistic generalization remain unknown.
  • Romanized Tamil remains underexplored: Tanglish requires substantially more tokens than Tamil script, yet the paper does not evaluate performance separately across spelling conventions, dialectal romanization, code-switching patterns, or noisy user-generated text.
  • Training-data quality and representativeness are uncertain: Tamil data are repeated because high-quality supply is limited, but the paper does not establish how repetition affects memorization, diversity, overfitting, or performance on unseen contemporary Tamil.
  • Potential source and demographic bias is not characterized: The corpus composition is described by source categories, but there is no systematic analysis of geographic, socioeconomic, gender, ideological, dialectal, or register bias.
  • OCR-related errors may remain in the corpus: Although several OCR filters were manually checked, the residual error rate and its effect on pretraining, factuality, spelling, and literary-language performance are not measured.
  • Historical and classical Tamil coverage is insufficiently evaluated: The paper notes that digitized older Tamil is scarce and that classical text is underrepresented, but it does not test the model’s competence across historical periods, classical literature, or formal literary registers.
  • Data contamination checks are incomplete: Hash and substring scans may miss paraphrases, translations, OCR variants, near duplicates, and benchmark content introduced indirectly through upstream datasets.
  • Benchmark contamination affects interpretation: Some held-out passages come from books that are otherwise present in training, and several benchmarks are explicitly exempted from contamination checks. The extent to which reported scores reflect memorization remains unresolved.
  • Instruction-data provenance and synthetic-data effects are uncertain: Most assistant responses were generated by open-weight teacher models, but the paper does not quantify teacher-specific artifacts, stylistic bias, factual errors, or the effect of synthetic data on diversity and robustness.
  • Frontier-model influence is difficult to disentangle: Frontier models helped plan the work, write code, and potentially generate user-side text or upstream public data. The paper does not measure how this indirect influence affects the model’s behavior or evaluation outcomes.
  • Post-training improvements lack causal attribution: Several interventions—including DPO, GRPO, abstention training, safety tuning, character tuning, and targeted SFT—were tried sequentially, making it difficult to determine which components helped, harmed, or interacted with one another.
  • Targeted SFT does not generalize reliably: The targeted rounds improved probe items but did not improve unseen chat quality. The paper does not test whether broader coverage, alternative sampling, harder examples, or reinforcement-learning methods could produce transfer.
  • Knowledge deficits were not substantially addressed: Additional SFT experiments changed answer format without improving knowledge measures, but retrieval augmentation, continued pretraining on verified knowledge, tool-assisted answering, and explicit uncertainty training were not evaluated.
  • Tool-calling evaluation is too small and partly contaminated by training overlap: Tool use is measured on only 25 prompts, with tool schemas appearing in training. The evaluation does not establish robustness to unseen schemas, multi-step calls, malformed inputs, ambiguous requests, tool failures, or adversarial arguments.
  • Exact argument accuracy is low relative to tool-selection accuracy: The model selected the correct tool 23 of 25 times but produced exactly correct arguments only 13 times. The specific causes of argument-generation failures and effective remedies remain unexamined.
  • No end-to-end tool-use assessment: The paper evaluates tool selection and arguments but not whether the model can interpret tool outputs, recover from failures, decide when not to call a tool, or complete tasks reliably in realistic environments.
  • Safety performance is not comprehensively evaluated: The training includes crisis-support and safety data, but there is no systematic assessment of harmful advice, self-harm handling, privacy leakage, prompt injection, culturally specific risks, or safety behavior in Tamil, Tanglish, and English.
  • Abstention quality remains unclear: An abstention patch was attempted, but the paper does not report calibrated uncertainty, selective accuracy, false-confidence rates, or whether abstention reduces useful answers.
  • Long-context capability is unverified: The model uses an 8,192-token context and document-level attention masking, but there are no systematic tests of retrieval, reasoning, summarization, or instruction following across long Tamil and mixed-script contexts.
  • Scaling behavior is unknown: The architecture and training recipe were tested at a narrow scale. It remains unclear whether the observed translation gains, knowledge limitations, tokenizer trade-offs, and architecture choices persist at larger or smaller parameter counts and token budgets.
  • The architecture comparison is underpowered: Mamba and hybrid alternatives were evaluated only in a small model ladder and under one training setup. The results do not establish that dense Transformers are superior for Tamil at larger scales, longer contexts, or different optimization regimes.
  • Training instability and run-to-run variance are unknown: The main 2.5B model was trained only once, so the reproducibility of its results and the sensitivity of its scores to random seed, data order, checkpoint selection, and hardware conditions are not quantified.
  • Compute-efficiency claims are incomplete: The paper reports training time and cost but does not compare energy use, inference throughput, memory consumption, latency, or cost per useful Tamil token against adapted or multilingual alternatives.
  • Release and licensing constraints may limit reproducibility: Some datasets and tools cannot be redistributed, and the final licensing status is subject to legal review. Independent researchers may therefore be unable to reconstruct the exact corpus or training run.
  • Real-world deployment behavior is not evaluated: There is no study of performance under noisy prompts, spelling errors, mixed scripts, code-switching, conversational memory, repeated corrections, or sustained multi-turn use by native Tamil speakers.
  • Factuality and citation behavior are untested: The paper reports that most failed everyday answers contain wrong facts, but it does not measure source attribution, hallucination rates, calibration, correction after feedback, or performance when allowed to consult external retrieval systems.
  • User preference and human usefulness remain unresolved: No broad user study assesses whether Tamil speakers prefer the model’s script, Tanglish, translation style, tone, verbosity, refusal behavior, or tool-use behavior in practical applications.

Practical Applications

Immediate Applications

  • Tamil–English translation and localization — language services, media, public administration, and education.
    • translating websites, subtitles, product documentation, and customer-support content;
    • creating bilingual drafts for government notices and educational materials;
    • assisting human translators with terminology suggestions and post-editing.

Dependencies: Human review remains necessary for legal, medical, literary, and high-stakes content. chrF improvements do not guarantee factual or stylistic accuracy on every domain, and performance may vary across dialects, classical Tamil, OCR-damaged text, and specialized terminology.

  • Tamil and Tanglish customer-support assistants — retail, telecommunications, banking, and public services. The model can be deployed as a lightweight first-line chatbot that accepts Tamil script, Tanglish, or English and responds in those formats. Possible workflows include answering FAQs, routing support tickets, summarizing customer messages, and producing draft replies for human agents.

Dependencies: The paper reports only about 46% usable responses on a small everyday-question set, with most failures involving incorrect facts. Production systems should therefore use retrieval from approved knowledge bases, confidence thresholds, logging, and human escalation rather than relying on the model’s internal knowledge.

  • Tamil-language translation and text-processing APIs — software and developer tooling.
    • translation APIs;
    • Tamil/Tanglish normalization and rewriting;
    • bilingual search-query expansion;
    • document classification and summarization prototypes;
    • offline language assistance on commodity hardware through llama.cpp.

Dependencies: Applications must validate the release licence and the legal status of training and OCR sources. The 8,192-token context and 2.5B parameter size may constrain long documents, high-throughput workloads, and complex reasoning.

  • Structured tool-calling assistants — software automation and enterprise workflows.
    • calendars, ticketing systems, and inventory databases;
    • calculators, translation services, and document search;
    • government-service portals;
    • local business workflows such as appointment booking or order lookup.

Dependencies: The reported tool evaluation contained only 25 prompts, and the model produced exactly correct arguments on 13 of them. Tool calls must therefore be validated against schemas, authenticated, sandboxed, and checked by deterministic application code before execution.

  • Offline and privacy-preserving Tamil assistants — personal computing, schools, and community organizations. Quantized GGUF models can enable local inference for users with limited connectivity or privacy requirements. Potential uses include drafting messages, translation, basic writing assistance, and Tamil-language interfaces for community software.

Dependencies: Actual speed and memory requirements depend on quantization and hardware. Since factual reliability is limited, the model should not independently provide medical, legal, financial, or emergency advice.

  • Tamil educational content production — schools, tutoring platforms, and academic publishing. The model can generate draft explanations, exercises, bilingual glossaries, and translations for teachers and content teams. Its strong Tamil text modeling and translation capability may help expand the supply of Tamil-first digital learning materials.

Dependencies: Generated content requires teacher or subject-matter review. The weak knowledge and reading-comprehension results make unsupervised tutoring inappropriate, particularly for factual curricula, examinations, and student assessment.

  • Research and teaching infrastructure for under-represented-language NLP — academia.
    • Tamil tokenization and Tanglish processing;
    • low-resource LLM training;
    • OCR-quality filtering;
    • tool-use fine-tuning;
    • evaluation of multilingual and regional-language systems.

Dependencies: Reproduction requires substantial compute, suitable licensed data, and careful separation of training and evaluation material. The paper’s results should not be generalized automatically to other languages or larger model scales.

  • Improved Tamil OCR and digitization workflows — libraries, archives, and cultural institutions. The paper demonstrates a practical pipeline combining OCR, narrow rejection rules, manual inspection of rejected material, deduplication, and language-model training. This can inform digitization of Tamil books, newspapers, and archival collections.

Dependencies: OCR output remains a major source of error. Copyright, cultural heritage permissions, scan quality, legacy fonts, and human verification are central operational constraints.

Long-Term Applications

  • Reliable Tamil public-service and government assistants — policy and civic technology. A stronger successor could provide Tamil-first access to government schemes, forms, benefits, and procedural guidance through chat, voice, or messaging platforms. Tool calling could connect the model to verified service databases and application systems.

Dependencies: This requires substantially better factual grounding, retrieval, multilingual speech support, security, accessibility testing, auditability, and legal accountability. The current model’s near-chance knowledge benchmarks and frequent factual errors make autonomous public-service advice unsuitable.

  • Healthcare information and navigation in Tamil — healthcare and telemedicine. Future systems could translate medical instructions, explain appointment procedures, collect structured patient information, and help users navigate local health services. A tool-enabled model could retrieve information only from approved clinical sources.

Dependencies: The current model should not diagnose, recommend treatment, or triage emergencies. Deployment would require medically curated retrieval, clinician validation, privacy protections, safety evaluations, and regulatory compliance.

  • Tamil educational tutors with grounded curricula — education technology. A future model could provide adaptive tutoring in Tamil script and Tanglish, generate exercises aligned with state curricula, and give step-by-step explanations. The paper’s native-Tamil instruction tuning and formatting improvements offer a foundation for such systems.

Dependencies: Further research is needed on factuality, age-appropriate behavior, curriculum alignment, evaluation by Tamil-speaking educators, and prevention of confidently wrong explanations. Retrieval or curriculum-constrained generation would likely be essential.

  • Tamil voice agents and multimodal assistants — consumer technology and accessibility. Combining the model with speech recognition, text-to-speech, OCR, and vision systems could support voice-based assistants for users more comfortable speaking Tamil or Tanglish. Use cases include accessibility tools, elder-care interfaces, field-service applications, and hands-free device control.

Dependencies: The paper evaluates text only. Reliable deployment would require separate advances in Tamil speech recognition, dialect coverage, code-switching, noisy-environment robustness, latency, and safety.

  • Tamil-first enterprise copilots — finance, logistics, agriculture, and small businesses. With domain-specific retrieval and validated tools, successors could summarize records, draft invoices, query inventory, translate business communications, and automate routine workflows for Tamil-speaking organizations.

Dependencies: Domain adaptation, structured data integration, access control, audit trails, and resistance to prompt injection are required. Financial and operational decisions must remain subject to deterministic checks and human approval.

  • Digital preservation and exploration of Tamil literature — humanities and cultural technology. Improved models could assist with OCR correction, search, translation, annotation, modernization of archaic language, and discovery across large Tamil literary collections. This could make historical works more accessible to researchers and general readers.

Dependencies: Classical and literary Tamil are underrepresented in the training mix, and the tokenizer was less efficient on verse. Preservation workflows must retain original text, distinguish generated interpretations from source material, and involve domain experts.

  • A reusable training playbook for other under-represented languages — academia, government, and nonprofit technology. The project’s measured tokenizer design, language-majority data mixture, targeted SFT, checkpoint safeguards, contamination checks, and multi-pass evaluation can be adapted to other low-resource languages. Small teams could use this approach to build locally relevant models rather than relying entirely on English-centric systems.

Dependencies: The method depends on access to sufficiently large, legally usable corpora, native-speaker evaluation, compute funding, and language-specific engineering expertise. Results may not transfer where digital text, OCR resources, or evaluation benchmarks are much scarcer.

  • More dependable Tamil agents through retrieval-augmented generation and verification — software and robotics. A future version could combine the compact model with search, databases, calculators, code execution, or robotic control. Tamil-language commands could be converted into verified actions, while external tools provide current facts that the base model lacks.

Dependencies: Tool selection and argument accuracy must improve beyond the small reported test set. Robotics and physical automation additionally require real-time guarantees, perception, fail-safe controls, simulation, and strict separation between language generation and actuation.

  • Policy tools for measuring language inclusion and digital access. Governments, NGOs, and platforms could use Tamil-first models and the paper’s evaluation approach to audit whether digital services work adequately in Tamil script, Tanglish, and English. Such audits could guide procurement standards, language-access requirements, and public-sector AI policy.

Dependencies: Evaluations need larger, professionally authored, culturally diverse test sets; independent human raters; dialect and register coverage; and protections against benchmark contamination. The paper’s small held-out chat set and variable LLM-judge scores are insufficient as a standalone policy metric.

Glossary

  • Adam: An adaptive gradient-based optimization algorithm used to train neural networks. “The optimizer is Adam with β=(0.9,0.95)\beta=(0.9, 0.95), weight decay 0.1 and gradient clipping at 1.0”
  • Attention: A neural-network mechanism that weights the relevance of different tokens when processing a sequence. “Attention never crosses a document boundary.”
  • Bits per character: A tokenizer-independent measure of how well a LLM predicts text, expressed as the average number of bits needed per character. “We track bits per character on a held-out set of 541 Tamil passages in five registers, kept out of training”
  • Byte-level BPE: A byte-pair encoding tokenizer that begins with individual bytes and repeatedly merges frequent adjacent sequences. “A byte-level BPE starts from the 256 possible bytes, so it can encode any text”
  • Checkpoint: A saved snapshot of a model’s parameters and training state. “The final checkpoint reached the copier at 07:48 and the local archive at 08:02”
  • chrF: A machine-translation metric based on character n-gram overlap between a generated translation and a reference translation. “Translation is scored with chrF”
  • Context window: The maximum sequence length that a model can process at once. “Context 8,192 tokens; full multi-head attention”
  • Contamination: The presence of evaluation or benchmark material in a model’s training data. “The report describes the full recipe at a scale a student team can reproduce.”
  • Cosine schedule: A learning-rate schedule that changes the learning rate according to a cosine-shaped curve. “Unlike a cosine schedule, this does not fix the length of the run in advance”
  • Decoder-only Transformer: A Transformer architecture that uses only autoregressive decoder blocks to predict subsequent tokens. “அகரம் 2.5B is a dense decoder-only Transformer with 2,525,757,696 parameters”
  • Deduplication: The process of removing duplicate or near-duplicate training examples. “The pack holds 39.39B unique tokens from 68 sources, drawn to 50B training tokens with repeats”
  • Direct Preference Optimization (DPO): A method that fine-tunes a model to prefer a chosen response over a rejected response without explicitly training a separate reward model. “two runs of direct preference optimisation (DPO, which trains a model to prefer a chosen reply over a rejected one)”
  • Embedding: A learned numerical representation of a token or other discrete object. “input and output embeddings tied over the 64,000-token vocabulary”
  • Epoch: One complete pass through a training dataset. “SFT 134K conversations 3 epochs”
  • Fine-tuning: Additional training of a pretrained model on a narrower or task-specific dataset. “We pretrained it on about 50 billion tokens, 58\% of them Tamil, on one node of eight H100 GPUs in six days, then fine-tuned it on 134,428 conversations”
  • FLORES: A multilingual benchmark suite used to evaluate machine translation. “The released model translates better than Sarvam-1, a 2B Indic base model, in all six FLORES and IN22 directions”
  • Flash attention: An optimized attention implementation that reduces memory use and improves computational efficiency. “each document attends only to itself, rotary positions restart at each document, and flash attention stays on.”
  • Gated DeltaNet: A sequence-modeling layer that uses gated state updates as an alternative to standard Transformer attention. “A hybrid with Gated DeltaNet layers trailed the dense model at 25,000 steps.”
  • Gradient clipping: A technique that limits gradient magnitude to stabilize neural-network training. “weight decay 0.1 and gradient clipping at 1.0”
  • Group Relative Policy Optimization (GRPO): A reinforcement-learning method that evaluates several sampled responses relative to one another. “a run of group relative policy optimisation (GRPO, a reinforcement-learning method that scores several sampled replies against each other)”
  • Held-out set: Data excluded from training and used to measure generalization. “We tested it at small scale with a ladder of models of about 91M parameters, three random seeds each, trained for up to 75,000 steps”
  • Instruction tuning: Training a model on examples formatted as instructions and responses so that it follows user requests. “instruction-tuned models evaluated the same way”
  • Log-likelihood: The logarithm of the probability assigned by a model to an observed sequence or answer. “Multiple-choice tasks are scored by log-likelihood”
  • Mamba: A state-space sequence-modeling architecture designed to process long sequences efficiently. “We began in May 2026 planning a hybrid of Mamba and attention layers.”
  • Mixture of experts: A model architecture containing multiple specialized subnetworks, with only a subset activated for each token. “both are mixture-of-experts models”
  • Mixed precision: Training that combines numerical formats of different precision to reduce memory use and accelerate computation. “in bf16 mixed precision with the optimizer state distributed across the eight GPUs”
  • Morphological tokenizer: A tokenizer designed to divide text according to morphemes or other linguistic units. “a morphological tokenizer we measured in July split Tamil words far more finely and was not adopted.”
  • Multi-head attention: An attention mechanism that computes multiple attention patterns in parallel. “36 attention heads of dimension 64 (full multi-head attention)”
  • OCR: Optical character recognition, the conversion of text in images or scanned documents into machine-readable text. “Much printed Tamil exists only as scanned images, so we ran Tesseract OCR”
  • Overfitting: The tendency of a model to fit training data too closely and perform worse on unseen data. “it fitted its training text better and generalised worse.”
  • Pretraining: The initial large-scale training of a model, generally on broad unlabeled or weakly labeled text. “We pretrained it on about 50 billion tokens”
  • Quantization: The reduction of numerical precision used to represent model parameters, often to reduce memory and storage requirements. “with GGUF files for llama.cpp”
  • Reinforcement learning: A training paradigm in which a model improves by receiving evaluative signals for sampled actions or outputs. “a run of group relative policy optimisation (GRPO, a reinforcement-learning method that scores several sampled replies against each other)”
  • Residual connection: A neural-network connection that adds a layer’s input to its output to improve optimization in deep networks. “The decoder block, repeated 28 times (pre-norm; teal lines are the residual connections)”
  • Rotary position embeddings (RoPE): A positional encoding method that represents token positions by rotating query and key vectors. “rotary position embeddings with base 500,000”
  • SentencePiece: A subword-tokenization system that learns token units directly from raw text. “The first model's tokenizer (TOK_BPE_64K, a SentencePiece BPE)”
  • SFT: Supervised fine-tuning, in which a model learns from input-output examples supplied by human or generated annotators. “The final SFT set has 134,428 training conversations and 2,736 validation conversations”
  • State-space model: A sequence model that represents evolving hidden states and can process sequences with computational cost that grows linearly with sequence length. “Mamba is a state-space layer”
  • Subword tokenization: The division of text into units smaller than or comparable to words, such as character sequences or word pieces. “A model reads text as tokens, pieces of words drawn from a fixed vocabulary”
  • Tesseract: An open-source OCR engine used to extract text from images. “we ran Tesseract OCR over the Tamil Digital Library”
  • Token: A discrete unit of text processed by a LLM. “A model reads text as tokens, pieces of words drawn from a fixed vocabulary”
  • Tokenizer: A system that converts text into a sequence of model-readable tokens. “its tokenizer was trained on our own mix of Tamil, English, code and chat text”
  • Tool calling: The generation of structured requests that invoke external tools or functions. “the first Tamil-first model trained from scratch that does tool calling.”
  • Training corpus: The collection of documents or tokens used to train a model. “The pack holds 39.39B unique tokens from 68 sources”
  • Transformer: A neural-network architecture based primarily on attention mechanisms for modeling sequences. “No hybrid met the rule, so both அகரம் models use the dense Transformer block.”
  • Validation loss: The model’s prediction loss measured on data excluded from parameter updates during training. “Validation loss during training usually falls as a power law in the number of steps”
  • Vocabulary: The set of tokens that a tokenizer can produce. “Both have 64,000 ids and round-trip every test set exactly.”
  • Weight decay: A regularization method that penalizes large model parameters during optimization. “weight decay 0.1 and gradient clipping at 1.0”

Tweets

Sign up for free to view the 2 tweets with 334 likes about this paper.