Jais 3 Explained: The Open Arabic LLM Family From 0.9B to a 375B MoE (Benchmarks, Code, License)

If you have ever typed a question in Egyptian or Gulf Arabic into a general-purpose chatbot and received stiff newspaper Arabic back, or watched an English-first tokenizer chop every Arabic word into four or more pieces, you have already met the problem that Jais 3 was built to attack. On October 15, 2026, MBZUAI's Institute of Foundation Models (IFM) and Inception42 released Jais 3, a family of six open Arabic-centric language models from 0.9 billion to 375 billion parameters, plus Jais Speech, an Arabic speech recognition model, and a 24-benchmark Arabic evaluation suite that was audited for defective questions [1][2][3].

This post covers why Arabic is structurally harder for language models than English, what the six checkpoints are (with config numbers I read straight from the Hugging Face repositories), how the training recipe works, what the benchmark tables say including the rows where Jais 3 loses, how it compares with earlier Jais generations, and how to run it from the 0.9B model up to the 375B flagship. Three scripts here are ones I ran myself: a tokenizer fertility comparison, a GPU memory calculator, and a counter over the benchmark audit data. The serving commands are adapted from the official model cards and I did not run them on a GPU cluster.

A note on sources. The IFM blog post sat behind bot protection when I tried to read it, so every number below comes from the model cards and repository metadata on Hugging Face, launch coverage such as Gulf News, or a secondary summary that I label as such.

TL;DR: Jais 3 in One Table

The family is built on K2 Horizon, IFM's fully open foundation model fleet released in September 2026, and every member starts from the final post-trained K2 Horizon checkpoint of the same size before going through an Arabic adaptation recipe [3][15]. The K2 Horizon 375B-A23B base is itself fully open, with checkpoints, data, and training code released [14]. All six ship under Apache 2.0 with a 512K-token context window, except the 0.9B model, which has 128K [4][9]. The numbers below come from each repository's config.json and model card.

The headline claims from the developers are that the 375B model leads open models on agentic tasks and matches the strongest on Arabic understanding, that the 3.7B model beats every open model up to 5B on Arabic and agentic tasks, and that at 7B the average Arabic evaluation score rose from 56.4 for the K2 Horizon base to 79.6 for Jais 3 [3]. I check those claims against the published tables later, and the picture is more mixed than the headline.

Why Arabic Is Hard for Language Models

Arabic has more than 400 million speakers, and the original Jais paper opened with exactly that observation: a language this large had been noticeably underrepresented in the LLM space [18]. The difficulty has four separate layers, and Jais 3's design choices make more sense once you see them apart.

Tokenizer fertility: the cost you pay before the model runs

Fertility is the average number of tokens a tokenizer needs per word. A tokenizer trained mostly on English splits Arabic words, which are rich in prefixes, suffixes, and attached pronouns, into many small pieces. That inflates cost, latency, and context use for every Arabic request, and Petrov and colleagues showed that the same text can tokenize to wildly different lengths across languages, with multilingual tokenizers still showing large gaps [24].

The original Jais paper measured this directly. Its custom 84,992-token vocabulary scored a fertility of 1.050 on Arabic, compared with 4.171 for GPT-2's tokenizer, 1.195 for BLOOM's 250,000-token vocabulary, and 1.125 for a BERT Arabic tokenizer [18]. I wanted to see where the Jais 3 tokenizer stands today, so I wrote a small script that counts tokens per whitespace-separated word on a hand-written parallel sample: the same three sentences in English, Modern Standard Arabic, Egyptian Arabic, and Gulf Arabic. The sample is tiny, so treat the exact decimals as illustrative, but the ordering is stable.

bash
/code
python3 -m venv jais-env && source jais-env/bin/activate
pip install tokenizers tiktoken huggingface_hub

python
/code
"""Tokens-per-word (fertility) for Arabic vs English on a small hand-written parallel sample."""
import tiktoken
from tokenizers import Tokenizer
from huggingface_hub import hf_hub_download

SAMPLES = {
    "English": [
        "The ministry announced that the new school year will begin next week.",
        "I am going to the market to buy vegetables and bread.",
        "What do you want to eat tonight, should we order something?",
    ],
    "Arabic (MSA)": [
        "أعلنت الوزارة أن العام الدراسي الجديد سيبدأ الأسبوع المقبل.",
        "سأذهب إلى السوق لشراء الخضروات والخبز.",
        "ماذا تريد أن تأكل الليلة، هل نطلب شيئا؟",
    ],
    "Arabic (Egyptian)": [
        "الوزارة قالت إن السنة الدراسية الجديدة هتبدأ الأسبوع الجاي.",
        "رايح السوق أشتري خضار وعيش.",
        "عايز تاكل إيه الليلة، نطلب أي حاجة؟",
    ],
    "Arabic (Gulf)": [
        "الوزارة قالت إن السنة الدراسية الجديدة بتبدا الأسبوع الجاي.",
        "بروح السوق أشتري خضار وخبز.",
        "شو تبي تاكل الليلة، نطلب شي؟",
    ],
}

def hf_tok(repo):
    path = hf_hub_download(repo, "tokenizer.json")
    t = Tokenizer.from_file(path)
    return lambda s: len(t.encode(s, add_special_tokens=False).ids)

counters = {
    "Jais-3-7B (250,624 vocab)": hf_tok("inception42/Jais-3-7B"),
    "Jais-3-0.9B (64,256 vocab)": hf_tok("inception42/Jais-3-0.9B"),
    "tiktoken cl100k_base": lambda s: len(tiktoken.get_encoding("cl100k_base").encode(s)),
    "tiktoken o200k_base": lambda s: len(tiktoken.get_encoding("o200k_base").encode(s)),
}

print(f"{'tokenizer':30s}" + "".join(f"{k:>20s}" for k in SAMPLES))
for name, count in counters.items():
    row = []
    for lang, sents in SAMPLES.items():
        words = sum(len(s.split()) for s in sents)
        toks = sum(count(s) for s in sents)
        row.append(toks / words)
    print(f"{name:30s}" + "".join(f"{r:20.2f}" for r in row))

Here is what it printed on my machine.

Two things stand out. First, an English-centric tokenizer such as cl100k pays about 4.2 tokens per Arabic word, almost four times its English rate of 1.12, while the Jais 3 7B tokenizer sits at 1.22 on MSA. Second, dialect text costs more than MSA even for a tokenizer built for Arabic: 1.57 and 1.55 tokens per word for Egyptian and Gulf, against 1.22 for MSA. That gap is the tokenizer telling you that dialectal spellings are rarer in its training text, which matters because Jais 3 explicitly targets dialects. The 0.9B model uses a smaller 64,256-entry vocabulary and pays for it, at 1.48 on MSA and about 1.7 on dialects [9].

Diglossia: two Arabics in one speaker

Arabic speakers live in diglossia. Modern Standard Arabic (MSA) is the written and formal register taught in schools and used in news and law, while everyday speech happens in regional dialects such as Egyptian, Gulf, Levantine, and Maghrebi, which differ from MSA and from each other in vocabulary, morphology, and sometimes word order.

A model can therefore ace MSA exam questions and still fail a customer who writes in Emirati dialect, mixes in English mid-sentence, or types Arabic in Latin letters (Arabizi). Jais 3's own launch language leans into this. Haonan Li, a senior research scientist at IFM, said the team built Jais 3 for Arabic as it is really used, including switches into English or French mid-sentence [3]. Benchmarks designed for this layer exist, for example AraDiCE, which pairs machine translation with human post-editing to build dialectal and cultural evaluation sets and reports that Arabic-specific models such as Jais outperform multilingual models on dialect tasks while dialect identification and generation remain hard [25]. The QADI corpus behind the Dialect Identification row in Jais 3's tables covers 18 country-level dialects from roughly 540,000 tweets [27].

Benchmarks: translated, defective, or both

The fourth layer is measurement. Many early Arabic evaluations were translations of English benchmarks, which import English cultural assumptions and translation artifacts. ArabicMMLU was a deliberate response: 14,575 multiple-choice questions across 40 tasks, drawn from school exams in North Africa, the Levant, and the Gulf and built with native speakers, where in 2024 the top Arabic-centric model reached only 62.3% [26]. Native benchmarks have their own problem: a question with two identical options, or a key that points to the wrong one, penalizes a correct model and rewards a lucky guess. The audit section below covers this, because it is the most reusable part of the release.

One distinction matters here. The audit IFM published fixes label quality, which is different from contamination, meaning test questions leaking into training data. The cards and coverage I read do not describe a contamination analysis, so I treat the audited numbers as cleaner but not contamination-proof.

Step 1: What Was Released on October 15, 2026

The release has four layers: six language models, quantized and format variants, Jais Speech, and the audited benchmark collection. The six checkpoints are Jais-3-0.9B, Jais-3-3.7B, Jais-3-7B, and Jais-3-32B (all dense), Jais-3-MoVA-36B-A4B (a mixture-of-experts model with Mixture-of-Values attention that stores 36B parameters and runs 4B per token), and the flagship Jais-3-375B-A23B (a sparse mixture-of-experts model that stores 375B and runs 23B per token) [4][6][11].

The developers describe the 0.9B model as small enough to run on a phone [3], and the Hugging Face collection ships GGUF files for llama.cpp, MLX builds for Apple silicon, and FP8 versions of several sizes [7][11]. Each model repository also exposes training branches named CPT, Cooldown, SFT, and FTPO next to the final weights, which together with the final weights matches the launch claim of five training checkpoints per model [3][4].

Ashish Koshy, CEO of Inception42, told Gulf News that an Arabic LLM is not a translation exercise [3]. Cerebras Systems collaborated on the work, as it did on the previous generation [3][20].

Where Jais 3 sits in the Jais lineage

The original Jais and Jais-chat paper (August 2023) described a 13B model pretrained on 395 billion tokens: 72 billion Arabic tokens repeated 1.6 times for an effective 116 billion, 232 billion English tokens, and the rest code, with ALiBi positional encodings, SwiGLU, and a 2,048-token context [18]. In August 2024 Inception released 20 Jais models across 8 sizes from 590M to 70B trained on up to 1.6 trillion tokens [21]. Jais 2 followed on December 9, 2025, with a 70B model trained from scratch and an 8B sibling, built with Cerebras and described in a paper as using a custom Arabic-centric vocabulary and a much smaller token budget than comparable models [19][20].

The strategic change in Jais 3 is that it no longer trains an Arabic model from scratch. It adapts a general-purpose open foundation, K2 Horizon, which already carries agentic and reasoning skills, and teaches it Arabic. Konsulteer's launch coverage describes Jais 3 as the first adaptation of K2 Horizon to another language [17]. That explains why the 512K context window and tool-calling skills arrive at every size.

Step 2: Architecture and Model Sizes

Every Jais 3 checkpoint reports the architecture class K2HorizonForCausalLM and the model type k2_horizon in config.json, which means a single modeling file covers the whole family and the same reasoning and tool-call parsers work at every size [4][7]. I pulled the configs for all six repositories and summarized the numbers that differ.

All six use grouped-query attention with 8 key-value heads regardless of size, which keeps the KV cache small relative to model width; this is why the 512K context is practical on modest hardware. The two sparse models route each token to 8 experts, drawn from a pool of 100 in the 36B model and 192 in the flagship. The 375B model therefore touches roughly 6% of its parameters per token (23B of 375B), which is the whole economic argument for mixture-of-experts: you pay memory for 375B but compute for 23B [4].

The MoVA label on the 36B model stands for Mixture-of-Values attention, per the model card, and the 36B model uses a hidden size of 2,560, the same as the dense 3.7B model, across 48 layers [6][8]. The technical report and code repository are both listed as coming soon, so I will not speculate on the attention internals [4].

For capacity planning, note that the safetensors metadata counts 379,167,159,168 parameters in the flagship and 8,999,178,240 in the 7B, higher than the headline sizes because embeddings with a 250,624-token vocabulary are included.

Step 3: The Training Recipe

Every Jais 3 model follows the same five-stage recipe, which is why IFM says all six share the training recipe and agent capabilities [3]. The stage-by-stage token counts below come from AlphaSignal's summary of the IFM blog post, which is a secondary source for me; the checkpoint branch names are confirmed on the model cards [4][15].

Three decisions in this recipe are worth understanding.

First, the replay mix. In continued pretraining, 151.09B of the 201.45B tokens are Arabic and 50.36B are replayed from K2 Horizon's mid-training data, a 75/25 split that was chosen after comparing 90/10, 75/25, and 50/50 [15]. Replay is the standard defense against catastrophic forgetting: if you train only on Arabic, the model drifts away from the agentic, coding, and reasoning skills that made the base valuable. The 7B Arabic average moved from 56.4 to 79.6 [3], though I found no published table showing how much English or agentic skill it retained.

Second, the data composition. AlphaSignal's summary reports that dialect-focused sources are about 36% of Arabic training tokens and that synthetic or machine-translated material is about 59% [15]. That is a high synthetic share, which makes sense for skills like Arabizi, poetry meter, and iʿrāb analysis (Arabic grammatical case parsing), where real labeled examples barely exist on the web, and it carries the risk that synthetic data inherits the style of whatever model generated it.

Third, the anti-loop stage. FTPO (Final Token Preference Optimization) is a short LoRA preference update trained on pairs mined from the model's own looping outputs. IFM's K2 Horizon card describes it as removing runaway repetition, with runaway generations almost entirely eliminated and standard benchmarks staying flat or improving slightly [13]. AlphaSignal's summary of Jais 3 reports the average loop rate falling from 13.8% to 1.2% [15].

Step 4: The Audited 24-Benchmark Suite

AraGen, the open-ended generation benchmark from Inception, MBZUAI, and Hugging Face, uses an LLM judge to score answers on six dimensions known as 3C3H (Correctness, Completeness, Conciseness, Helpfulness, Honesty, and Harmlessness), and Jais 3's cards report all six [28]. The suite spans knowledge, culture, dialects, linguistics, translation, instruction following, factuality, and agentic tasks [4]. The model cards mark audited benchmarks with an asterisk and state the rule plainly: items with ambiguous questions, invalid answer options, or indefensible gold labels were excluded, and scores are reported on the cleaned sets [4].

The audit method is documented in the IFM/discarded_samples dataset and the Arabic-Benchmark-Auditing collection [22][23]. In short: for each benchmark, IFM took the strongest baseline models, collected the union of items at least one of them got wrong, and sent each candidate to three LLM judges (GPT-5.6 Sol, Gemini 3.8 Flash, and Claude Opus 5). An item is discarded only when all three judges independently flag a significant problem, such as missing information, multiple valid answers, or a wrong key [22].

I downloaded the discarded files and counted them.

python
/code
import json
from huggingface_hub import hf_hub_download

BENCHMARKS = ["arabicmmlu", "dialectal_arabic_mmlu", "medarabench", "arastem", "fannorflop_mcq",
              "belebele_arabic", "gat_math", "qias_1", "arabculture", "palmx2025_2"]

total = 0
for name in BENCHMARKS:
    path = hf_hub_download("IFM/discarded_samples", f"data/{name}/discarded.jsonl", repo_type="dataset")
    rows = [json.loads(line) for line in open(path, encoding="utf-8")]
    total += len(rows)
    # Each row keeps the three judges' verdicts (gpt, gemini, opus) next to the original item
    print(f"{name:24s} {len(rows):5d} discarded")
print("total", total)

# Show one defective item: the answer key points at option B, but A and B are identical
path = hf_hub_download("IFM/discarded_samples", "data/arabicmmlu/discarded.jsonl", repo_type="dataset")
first = json.loads(open(path, encoding="utf-8").readline())
print(first["subset"], first["options"], "gold:", first["gold_label"])
print(first["gpt"]["sub_label"], "|", first["gpt"]["severity"])

The ArabicMMLU count of 765 matches the figure AlphaSignal reports, and the first record in that file is a clean illustration of the problem: an accounting question whose options A and B are identical, with the gold label set to B [15][22]. No model can answer that item correctly on the merits, so a high scorer on it is just lucky.

IFM's own documentation states the caveat: because the audit starts from failures by strong baselines, it does not catch defects in items every baseline answered correctly [22]. The cleaned sets are better, not perfect, and every discarded item is public with each judge's verdict.

Step 5: Benchmark Results, Including Where Jais 3 Loses

All the numbers in this section come from the official model cards, which report developer-run evaluations on IFM's own harness and cleaned benchmark sets. Independent replication did not exist at publication time, and trade coverage said so explicitly [4][7][37]. High reasoning effort was used for all reported results, and a few rows use specific protocols such as pass@1 or Avg@3 [4].

The 375B-A23B flagship against four large MoE models

The reference models on the flagship card are Qwen3.5-397B-A17B, MiniMax M3, Qwen3.8-Flash-Next, and NVIDIA Nemotron 3 Ultra [4]. The rows below show both wins and losses.

Reading the table row by row gives a more specific verdict than the headline. On Arabic understanding the flagship is at or near the top (Belebele, for reference, is a parallel reading comprehension dataset covering 122 language variants [31]): it ties Qwen3.8-Flash-Next at 89.3 on Arabic MMLU, leads Belebele at 95.6, leads the Dialect Identification row by a wide margin (71.1 against a best reference of 62.3), and leads Arabic IFBench at 93.9 against 81.7 for the next model [4]. Its translation score is also the highest in the table (91.9 on FLORES200+, judged by an LLM).

It trails on several rows that matter commercially. On AraGen v3, the open-ended generation benchmark, it scores 72.4 against 78.9 for Qwen3.5-397B-A17B, and its Arabic GSM8K score of 86.8 is the lowest of the five models [4]. On agentic work, the "leads open models on agentic tasks" headline needs a qualifier: against this particular reference set, Qwen3.8-Flash-Next is ahead on eight of the nine agentic rows I checked, for example 86.1 versus 73.8 on Terminal Bench 2.1 and 80.8 versus 70.2 on SWE-Bench Verified, while Jais 3 wins MCPMark (68.5 against 66.9) [4]. AlphaSignal's summary is more careful: it places the flagship second among large open models on the agentic aggregate, behind Qwen3.8-Flash-Next, and it also says the flagship leads the Arabic file processing comparison, but the card shows 64.1 for Jais against 82.7 for Qwen3.8-Flash-Next on that row, so I would not repeat that particular claim [4][15].

The factuality row is the most interesting one. On SimpleQA Verified in Arabic, the aggregate is 2/3 F-score plus 1/3 non-hallucination rate. Jais 3 scores only 8.5 on F-score (Qwen3.5-397B-A17B scores 53.0) but 76.7 on non-hallucination rate (Qwen3.5-397B-A17B scores 1.5) [4]. In plain terms, the flagship answers fewer trivia questions, and when it does not know, it declines far more often than it bluffs. That suits a legal or medical assistant and hurts a trivia bot.

One aggregator headline claimed the models beat Qwen and Claude, but the page behind it gave no scores, so I treat it as marketing [36].

The 32B and 36B-A4B models against Qwen3.8-27B and Gemma-4-31B

The mid-size cards compare against Falcon-H1-34B-Instruct, Gemma-4-31B-it, Muse-Glimmer-30B, Qwen3.8-27B, and Fanar-2-27B [5][6]. Muse-Glimmer and Qwen3.8-27B are open models Miraflow has already covered in depth, in Meta Muse Glimmer Explained and Qwen3.8-27B Explained.

The 36B-A4B model is the efficiency story: with only 4B parameters active it lands within a few points of the dense 32B model on most Arabic rows and on SWE-Bench Verified (72.8 versus 72.4), while its non-hallucination rate on Arabic SimpleQA is 83.1 [5][6]. The mixed rows matter, though. Gemma-4-31B-it beats the 32B model on Arabic MMLU (89.5 versus 88.6) and Belebele, and Qwen3.8-27B leads on Terminal Bench 2.1 at 79.8 against 63.7 [5]. The press claim that the 32B has the highest average Arabic score among open models at its size depends on an average that the card does not tabulate, so I computed my own unweighted mean over 20 non-agentic Arabic rows from each card (table later in this section). Under that simple mean, Gemma-4-31B-it edges the 32B model by 0.6 points, which says the claim is plausible under IFM's weighting but not robust to a different one.

The 7B model: strong where it counts, weak on open-ended generation

At 7B, Jais 3 looks very good. It beats the 12B Gemma-4-12B-it on Arabic MMLU, Arabic IFBench (91.6 versus 75.3), Dialect Identification, and every agentic row, including Terminal Bench 2.1 (46.4 versus 27.3) and BrowseComp-Plus (67.7 versus 21.9) [7]. It loses to Gemma-4-12B-it on AraGen (55.0 versus 62.8) and on some STEM and medical rows. Allam 7B, Falcon-H1-7B-Instruct, and Fanar-1-9B-Instruct score near 0.0 on most agentic rows, which says they were never built for tool use [7].

The Arabic IFBench numbers across the whole family look odd until you remember the benchmark: 93.9 for the flagship, 88.7 for the 32B model, 91.6 for the 7B, 92.6 for the 3.7B, and 91.1 for the 0.9B [4][5][7][8][9]. The benchmark is marked with a caret on the cards and is listed as being released by IFM soon, so you cannot reproduce it yet. A score that flat across a 400x size range suggests the instruction-following data is doing the work, and it is a reason to wait for the public release before leaning on that row.

3.7B and 0.9B: the small models

Against Qwen3.5-4B, the 3.7B model leads Arabic MMLU (83.3 versus 75.2), Belebele (91.9 versus 84.0), Dialect Identification (68.8 versus 37.4), and Arabic IFBench (92.6 versus 53.7), and ties it on MedAraBench at 74.1, while its edge on AraSTEM is only 91.7 versus 91.4 [8]. The 0.9B model beats the 2B Qwen3.5-2B on AraGen (32.7 versus 15.3) and Arabic MMLU (70.4 versus 63.1) but loses on AraSTEM (81.6 versus 83.9) and MedAraBench (48.1 versus 54.3) [9]. The 0.9B card has no agentic rows, which is an honest signal about what that model is for.

An unweighted mean across 20 Arabic rows

To check the "highest average Arabic scores" claims independently, I averaged 20 non-agentic Arabic rows per card (AraGen v3, Arabic MMLU, Belebele, AraSTEM, Arabic GSM8K, GATmath, MedAraBench, Arabic Legal, IslamicQA, Arab Culture, Dialectal Arabic MMLU, Dialect Identification, Alyah, Arabic MMLU with diacritics, FannOrFlop, Arabic Linguistics, FLORES200+, Arabic IFBench, Arabic IFEval, and HalluScore). The 3.7B and 0.9B cards lack the FLORES row, so those two use 19 rows. This is my own calculation, and IFM's average (79.6 for the 7B) uses a different set and weighting.

My simple mean agrees with the shape of the official claims: the flagship tops its group at 85.9, the 7B tops its group at 81.2, and the 3.7B and 0.9B models top theirs by wide margins. The 32B and 36B-A4B models sit within about a point of Gemma-4-31B-it, which is why I would describe them as competitive with the best open models of their size rather than clearly ahead.

Step 6: Jais 3 Compared With Earlier Jais Generations

The cleanest like-for-like number from a primary source is the original Jais paper's Arabic zero-shot average: 46.5 for Jais 13B and 48.4 for the instruction-tuned Jais-chat 13B, compared with 38.1 for LLaMA2-chat 13B in the same table [18]. That was a strong result in 2023 on a different benchmark suite, so Jais 3's 79.6 for the 7B model must never share a chart with it.

What changed is structural. The 2023 model had a 2,048-token context, an 84,992-token vocabulary and a 13B dense design trained on 395B tokens [18]. Jais 3 has a 512K context, a 250,624-token vocabulary at most sizes, mixture-of-experts at the top, built-in tool calling, and a recipe that spends 201.45B tokens on continued pretraining instead of starting from zero [4][15]. Jais 2's paper claims leading results among evaluated open models on OALL2 and AraGen [19], and a secondary summary puts the Jais 2 70B Arabic average at 66.7 against 79.4 for the Jais 3 7B, a figure I could not confirm in a primary table and which differs slightly from the official 79.6 [3][15]. If it holds, a 7B model from October 2026 beats the 70B flagship from December 2025, which is the kind of progress an adaptation recipe on a strong open base would produce.

Step 7: Running Jais 3 Locally and Hosted

There are four paths: a hosted demo, a quantized local run, a single-GPU server, and a multi-GPU server for the flagship. The chat demo is at jaischat.ai, listed in launch coverage, and the weights are in the Jais 3 collection on Hugging Face [11][16].

Do the memory math before you rent anything

Weights dominate memory for a 375B model. I wrote a short calculator that uses the exact parameter counts from the Hugging Face metadata.

python
/code
"""Weight-memory arithmetic for the Jais-3 family (weights only, no KV cache or activations)."""
# Parameter counts from the Hugging Face safetensors metadata (BF16 = 2 bytes per parameter)
models = {
    "Jais-3-7B": 8_999_178_240,
    "Jais-3-375B-A23B": 379_167_159_168,
}
for name, n in models.items():
    gb = n * 2 / 1e9
    print(f"{name}: {n/1e9:.2f}B params -> {gb:,.0f} GB in BF16")

nodes = {"16x H100 80GB (2 nodes)": 16 * 80, "8x H200 141GB (1 node)": 8 * 141}
w = models["Jais-3-375B-A23B"] * 2 / 1e9
for label, total in nodes.items():
    print(f"{label}: {total} GB total, {total - w:,.0f} GB left after weights ({(total - w) / total:.0%})")

The output is 18 GB for the 7B in BF16 (matching the 18.01 GB BF16 GGUF file on its model card), 758 GB for the flagship, and 522 GB left over on the reference 16x H100 80GB deployment after weights, or 370 GB left on a single 8x H200 node [4][29]. The leftover holds your KV cache and activations. The card recommends two 8-GPU H100 nodes for the reference deployment and says a single 8x H200 node works with tensor and expert parallelism set to 8 [4].

Serve a small or medium model with vLLM

For the 7B model, the card's reference deployment is a single H100 with BF16, vLLM 0.30.0 or later, the k2_horizon reasoning parser, and the k2_horizon tool-call parser [7][32]. SGLang 0.5.20 or later is the other validated engine [7][33].

bash
/code
# Single 80 GB GPU. Needs vllm>=0.30.0 (per the Jais-3-7B model card).
pip install -U vllm
vllm serve inception42/Jais-3-7B \
  --trust-remote-code \
  --dtype bfloat16 \
  --tensor-parallel-size 1 \
  --reasoning-parser k2_horizon \
  --enable-auto-tool-choice \
  --tool-call-parser k2_horizon
# Serves an OpenAI-compatible API on http://localhost:8000/v1
# To test a training checkpoint instead of the final weights: add --revision SFT (or CPT, Cooldown, FTPO)

python
/code
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
response = client.chat.completions.create(
    model="inception42/Jais-3-7B",
    # Two numbers add up to 50 and multiply to 600. What are they? Explain the steps.
    messages=[{"role": "user", "content": "لدينا عددان مجموعهما 50 وحاصل ضربهما 600. ما هما العددان؟ اشرح خطوات الحل."}],
    temperature=0.7,   # Arabic thinking mode; use 1.0 for English thinking mode
    top_p=0.95,
    max_tokens=32768,  # reasoning needs room
    extra_body={"top_k": 20, "chat_template_kwargs": {"reasoning_effort": "high"}},
)
message = response.choices[0].message
print("Reasoning:", getattr(message, "reasoning_content", None))
print("Answer:", message.content)

The card is firm on settings: always pass reasoning_effort high, use temperature 0.2 by default, 1.0 for English thinking mode, and 0.7 for Arabic thinking mode, with top_p 0.95 and top_k 20, and allow at least 32,768 output tokens [7].

Serve the flagship

bash
/code
# Reference deployment from the model card: 16x H100 80GB across two 8-GPU nodes (multi-node launch needed).
# On a single 8x H200 node use --tensor-parallel-size 8 instead.
vllm serve inception42/Jais-3-375B-A23B \
  --trust-remote-code \
  --dtype bfloat16 \
  --tensor-parallel-size 16 \
  --enable-expert-parallel \
  --reasoning-parser k2_horizon \
  --enable-auto-tool-choice \
  --tool-call-parser k2_horizon

Load a specific training checkpoint

Each repository's CPT, Cooldown, SFT, and FTPO branches let you compare how a capability changes across the recipe. The card's Transformers example uses trust_remote_code and was validated with Transformers 5.15.0, PyTorch 2.13.0, and Safetensors 0.8.0 [7].

python
/code
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "inception42/Jais-3-7B"
revision = "SFT"  # CPT, Cooldown, SFT, FTPO, or "main" for the final weights

tokenizer = AutoTokenizer.from_pretrained(model_id, revision=revision, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id, revision=revision, device_map="auto", dtype="bfloat16",
    low_cpu_mem_usage=True, trust_remote_code=True,
)

inputs = tokenizer("اشرح لي الفرق بين الفصحى واللهجة المصرية في ثلاث جمل.", return_tensors="pt").to(model.device)
inputs.pop("token_type_ids", None)
outputs = model.generate(**inputs, max_new_tokens=2048, temperature=0.7, top_p=0.95, top_k=20, do_sample=True)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

On a laptop or Mac

The official GGUF repository for the 7B model offers BF16 (18.01 GB), Q8_0 (9.57 GB), Q6_K (7.39 GB), Q5_K_M (6.47 GB), Q5_0 (6.34 GB), and Q4_K_M (5.59 GB) files, and the card notes that K2 Horizon support was merged into llama.cpp, so you need a recent build and the jinja flag so reasoning and tool calls parse correctly [29].

bash
/code
# Build a recent llama.cpp with CUDA (K2 Horizon support is merged upstream), then pull the Q8_0 GGUF (9.57 GB).
cmake -B build -DGGML_CUDA=ON
cmake --build build -j --target llama-server
./build/bin/llama-server -hf IFM/Jais-3-7B-GGUF:Q8_0 --jinja -ngl 99 -c 32768
# Other variants: :BF16, :Q6_K, :Q5_K_M, :Q5_0, :Q4_K_M (5.59 GB)

MLX builds in 4-bit, 8-bit, and bf16 exist for Apple silicon [7].

Free speed: the Uno diffusion adapter

The Jais-3-7B-Uno repository is a rank-128 LoRA that makes the 7B model decode faster without changing its output distribution: a diffusion pathway drafts several future tokens and the original autoregressive weights verify them, so accepted tokens follow the base model's distribution exactly [12]. The method comes from the paper Unlocking Lossless Speedups in LLMs via Discrete Diffusion, and the inference engine is open source [34][35]. On one H100 with batch size 1 and greedy decoding, the card reports 124 tokens per second for the baseline and 239 for Uno, a 1.92x average speedup [12].

The idea is a diffusion-flavored cousin of Speculative Decoding, and Miraflow also covered DiffusionGemma. The limits are in the card: it needs a dedicated engine, it does not load with plain PEFT, and sampling speedups run 10 to 15 percent below greedy ones [12]. Cerebras, a Jais 3 collaborator, is also why wafer-scale inference keeps coming up, as explained in GPT-5.6 Sol Ultrafast on Cerebras.

Step 8: Jais Speech, the Arabic Speech Recognition Model

The speech model's Hugging Face name is Jais-ASR, and the launch press calls it Jais Speech. It is based on Jais-3-4B according to its card, ships under Apache 2.0, and transcribes Modern Standard Arabic and dialects from 19 Arab countries with code-switching into English, French, Spanish, and Italian [3][10]. It adds optional diacritization, built-in language and dialect identification, and an explicit no-speech signal: when audio has no speech, it returns the token [IFM-NoTranscript] with refused set to true instead of inventing text [10]. The bf16 weights are 11.4 GB, so roughly 12 GB of GPU memory is the planning number [10].

On the Open Universal Arabic ASR Leaderboard, which covers six public test sets, the card reports a macro-average word error rate (WER) of 22.85% and character error rate (CER) of 8.37%, ahead of every open-weight model compared and the commercial APIs from Speechmatics and ElevenLabs. IFM measured those two commercial systems itself [10][30].

The table has the same mixed shape as the text benchmarks. Jais-ASR has the best macro-average WER and CER and the best WER on three of the six sets (MASC clean, MASC noisy, and MGB-2 broadcast news), but it loses elsewhere. On Common Voice 18 MSA read speech it scores 8.56 WER, worse than Speechmatics Melia 1 at 5.19 and Cohere's Arabic model at 5.82, on SADA Saudi dialect broadcast Audar-ASR-V1-Turbo is better at 28.92 against 30.85, and on Casablanca Melia 1 edges it at 46.41 against 46.56 [10]. Casablanca, the conversational eight-dialect set, remains brutal for everyone, since every system in the table scores above 46% WER on it. If your audio is clean read speech, test several systems before assuming the leader of the average is the leader for you.

python
/code
# pip install 'transformers==5.16.1' accelerate soundfile soxr
import torch
from transformers import pipeline

asr = pipeline(
    "automatic-speech-recognition",
    model="IFM/Jais-ASR",
    trust_remote_code=True,
    device_map="auto",
    dtype=torch.bfloat16,   # bf16 weights are 11.4 GB
)
result = asr("speech.wav", max_new_tokens=256)
print(result["text"])

Step 9: Licensing and What Is Actually Open

The model cards for all six language models and for Jais-ASR list the license as apache-2.0, and coverage adds that weights, training checkpoints, and evaluation code are published under it [3][4][10]. Apache 2.0 allows commercial use, modification, and redistribution. Three edges are worth knowing:

• The technical report and code repository are marked coming soon, so today you can reproduce inference but not training [4].
• The audited datasets carry their own licenses; the verified ArabicMMLU set is listed as CC BY-NC 4.0, which is non-commercial [22].
• Government entities and enterprises can adapt the models and choose where to deploy them, in line with sovereign AI requirements, according to the launch announcement [3].

Common Mistakes When Evaluating or Deploying Jais 3

Using the default token budget. Reasoning at high effort needs room, so set max tokens to at least 32,768 as the cards recommend [4].

Skipping the parsers. Without the k2_horizon reasoning parser, thinking text lands in the answer, and without the tool-call parser, tool calls arrive as raw text. The cards say to leave both off for plain completion-style generation [4].

Evaluating on raw benchmarks. Published scores use cleaned sets at high reasoning effort, so your numbers will not line up if defective items are back in.

Reading the average as the answer. The 32B model's headline average hides rows where Gemma-4-31B-it is ahead, so pick the rows that match your workload.

Treating declines as failures. The high non-hallucination rate means Jais 3 declines often, so route refusals to search or retrieval rather than to the user.

Limitations and Open Questions

All benchmark claims are IFM's own, run on IFM's cleaned sets, and trade coverage notes that independent validation is pending [37][17]. Arabic IFBench, Arabic Cuisine, and Arabic Linguistics are marked as coming soon, so those rows cannot be replicated yet [4].

If roughly 59% of Arabic training tokens are synthetic or machine-translated, as the secondary summary says, the model may be strongest on styles that generation pipelines produce and weaker on messy, real regional text [15]. The card itself warns that the model can produce inaccurate or invented content, may reflect biases in training data, and should not drive medical, legal, financial, or safety-critical decisions without human oversight [4]. Hardware is the last constraint: the flagship needs two H100 nodes or one H200 node, so most teams will land on the 7B, 32B, or 36B-A4B models.

A Production Pattern That Fits These Models

Route short, latency-sensitive traffic to a 3.7B or 7B model on one GPU, where the Uno adapter can lift throughput. Send multi-step work such as file processing and tool chains to the 32B or 36B-A4B model, and reserve the 375B-A23B for the hardest agentic jobs. Put Jais-ASR at the front if users speak instead of type, since the family can then take spoken Arabic or English instructions and act on them [3]. Measure with your own dialect samples at every tier and log refusals separately from wrong answers.

Why This Matters If You Make Short-Form Video

You do not need to run a 375B model to feel better Arabic AI. Creators who publish Shorts for Arabic-speaking viewers know that MSA captions and the dialect the audience speaks can make a clip feel either native or dubbed.

Miraflow's AI Clipping tool takes a long video from a YouTube URL or an upload, finds the strongest moments, scores them, crops them vertically with face tracking, and adds animated captions, with 50+ languages auto-detected, so a multilingual creator can turn one podcast into several captioned clips; the workflow is walked through in How to Use AI Clipping to Turn Long Videos into 10 Viral Shorts Automatically and How to Turn a Podcast Into Viral Short-Form Clips With AI in 2026. If you start from a topic instead of footage, Text2Shorts writes the script, builds the scene visuals, and voices the video, and Miraflow's AI Clipping handles the repurposing side. Models like Jais 3 and Jais-ASR are the kind of open building blocks that will make Arabic-language versions of these workflows more accurate over time, and Miraflow is not claiming to use them today. The full creator pipeline lives at Miraflow.

For voice-heavy work, see AI Voice Cloning for Content Creators and Google Ads AI Video Dubbing in Asset Studio.

Generate Your Own Visuals for This Topic

If you want to illustrate your own Jais 3 explainer, the two prompts below are written to be used as is. The first is a Nano Banana style image prompt, which you can run in the Miraflow AI image generator, and the second is a Wan style video prompt for a short cinematic clip you can render with a tool such as Miraflow's cinematic video generator.

Image prompt, a photoreal tabletop still life of the model family:

A photoreal tabletop still life on a walnut desk in soft window light from the left, six glass apothecary jars in ascending size lined up like a set of nesting scales, each jar with a small paper tag tied on with string that reads 0.9B, 3.7B, 7B, 32B, 36B-A4B, and 375B-A23B, the jars filled with amber liquid to different heights, a printed index card propped in front that reads APACHE 2.0 and 512K CONTEXT, shallow depth of field with the nearest jar sharp, matte linen cloth underneath, no logos, no warped or garbled text, no watermark.

Video prompt, a short clip to open a talk or a Short:

A slow locked-off dolly push across a walnut desk toward six glass jars in ascending size, each with a paper tag reading 0.9B, 3.7B, 7B, 32B, 36B-A4B, and 375B-A23B, amber liquid gently settling in each jar, warm late-afternoon window light moving slowly from left to right across the tags, shallow depth of field racking focus from the smallest jar to the largest, subtle dust motes in the light, photoreal materials, 5 seconds, 16:9, smooth camera motion, no people, no on-screen text beyond the tags, no flicker, no morphing of the labels.

What to Watch Next

The technical report and code repository, both listed as coming soon, will reveal the data mix and stability details that coverage can only paraphrase [4]. Independent evaluation on dialect-heavy workloads matters most, since the audit cannot help there. Competition is also arriving fast: the same week's coverage lists an Egyptian startup's three open Arabic models, TII's Arabic Falcon for Emirati dialect, a Morocco and Mistral Darija model, and HUMAIN's 428B Arabic model built with MiniMax [16]. For how open mixture-of-experts models are landing more broadly, see Nemotron 3 Ultra Explained, one of the flagship's reference models.

Frequently Asked Questions

What is Jais 3?

Jais 3 is a family of six open Arabic-centric language models from 0.9B to 375B parameters, released on October 15, 2026 by MBZUAI's Institute of Foundation Models (IFM) and Inception42 with Cerebras Systems, together with Jais Speech for Arabic speech recognition. The models are built on IFM's K2 Horizon foundation and released under Apache 2.0 [3][4].

How big is the Jais 3 flagship, and how many parameters does it use per token?

The flagship, Jais-3-375B-A23B, is a sparse mixture-of-experts model that stores 375B parameters and runs 23B per token, with 192 routed experts and 8 active per token in its config and a 512K-token context window [4].

Is Jais 3 open source and can I use it commercially?

The model cards list Apache 2.0 for all six language models and for Jais-ASR, which permits commercial use. The technical report and code repository were still marked as coming soon on the model cards at launch, and some audited datasets carry their own licenses, such as CC BY-NC 4.0 for the verified ArabicMMLU set [4][10][22].

Does Jais 3 understand Arabic dialects, not just Modern Standard Arabic?

It was trained on Modern Standard Arabic and regional dialects including Emirati, Gulf, and North African Arabic, and its cards include dialect rows such as Dialectal Arabic MMLU, QADI dialect identification, and the Emirati Alyah benchmark. The flagship scores 71.1 on QADI against a best reference of 62.3 on its card, and the developer-run results are not yet independently replicated [3][4].

What GPU do I need to run Jais 3 locally?

A single H100 80GB is the validated reference for the 0.9B, 3.7B, and 7B models, two H100s for the 32B and 36B-A4B models, and two 8-GPU H100 nodes or one 8-GPU H200 node for the flagship. For a laptop, the 7B GGUF files range from 5.59 GB (Q4_K_M) to 18.01 GB (BF16), and MLX builds exist for Apple silicon [4][5][29].

How does Jais 3 compare with Jais 2?

Jais 2 (December 2025) was a 70B model trained from scratch with an 8B sibling, and Jais 3 adapts the K2 Horizon foundation instead, adds 512K context, tool calling, and mixture-of-experts sizes, and spans 0.9B to 375B. A secondary summary reports the 7B Jais 3 averaging 79.4 on Arabic against 66.7 for Jais 2 70B, but I could not verify that comparison from a primary table [15][19].

Can Jais Speech transcribe dialects and mixed Arabic-English speech?

Yes. The model card says it handles Modern Standard Arabic and dialects from 19 Arab countries and keeps English, French, Spanish, and Italian spans in their original script with code-switching enabled, and it can add diacritics and identify the dialect. It scored a 22.85% macro-average WER on the Open Universal Arabic ASR Leaderboard [10].

Are the Jais 3 benchmark results independent?

No. The scores come from IFM's own harness and its audited, cleaned benchmark sets, and trade coverage says independent validation is still needed. The audit data, including every discarded sample and the judges' verdicts, is public, which makes the method inspectable even though the results are not yet replicated [22][37].

Conclusion

Jais 3 is a serious attempt to answer the question Arabic AI has faced since the first Jais paper: how do you build a model that handles the language as people really use it, with dialects, code-switching, and diacritics, and still ships the agentic skills that frontier-style open models now carry? The answer IFM and Inception42 chose is to adapt a strong open base rather than train from scratch, spend about 201B tokens on a 75/25 Arabic and replay mix, add supervised and preference stages, and release six sizes with training checkpoints under Apache 2.0.

The numbers back most of the story and complicate the rest. The 7B and 3.7B models look excellent for their size on Arabic knowledge, dialect identification, and instruction following, and the flagship leads several Arabic understanding rows, while it trails Qwen3.8-Flash-Next on most agentic rows, trails on AraGen, and prefers declining to bluffing on trivia. Jais Speech has the best macro-average error rates on its leaderboard but loses individual sets. Every figure is developer-reported, and the most reusable contribution may be the audit itself: 765 defective ArabicMMLU items and thousands more across the other benchmarks, all published with the judges' reasoning.

If you build Arabic products, start with the 7B or 3.7B model on one GPU, evaluate on your own dialect samples, and use the audited sets for regression testing. If you make short-form video for Arabic-speaking audiences, Miraflow's Text2Shorts and AI Clipping cover the multilingual video side today while open models like these mature, and the Miraflow homepage has the rest of the pipeline.

References

[1] Institute of Foundation Models (IFM). "Jais 3: Introducing Arabic-centric Agentic AI"

[2] MBZUAI. "MBZUAI's Institute of Foundation Models and Inception42 Launch Jais 3: Arabic-native AI for speech, writing and agents"

[3] Gulf News. "UAE launches Jais 3, Arabic-native AI for speech, writing and agents"

[4] Hugging Face. "inception42/Jais-3-375B-A23B model card"

[5] Hugging Face. "inception42/Jais-3-32B model card"

[6] Hugging Face. "inception42/Jais-3-MoVA-36B-A4B model card"

[7] Hugging Face. "inception42/Jais-3-7B model card"

[8] Hugging Face. "inception42/Jais-3-3.7B model card"

[9] Hugging Face. "inception42/Jais-3-0.9B model card"

[10] Hugging Face. "IFM/Jais-ASR model card"

[11] Hugging Face. "Jais 3 collection (IFM)"

[12] Hugging Face. "inception42/Jais-3-7B-Uno model card"

[13] Hugging Face. "IFM/K2-Horizon-7B model card"

[14] Hugging Face. "IFM/K2-Horizon-375B-A23B model card"

[15] AlphaSignal. "MBZUAI Ships Jais 3, Six Open Arabic Models Beating Qwen and Claude"

[16] Middle East AI News. "MBZUAI, Inception42 launch Jais 3"

[17] Konsulteer. "MBZUAI and Inception42 Launch Jais 3 Arabic AI Models for Speech and Agents"

[18] arXiv. "Jais and Jais-chat: Arabic-Centric Foundation and Instruction-Tuned Open Generative Large Language Models (2308.16149)"

[19] arXiv. "Jais 2: A Family of Arabic-Centric Open Large Language Models (2608.13580)"

[20] Middle East AI News. "Inception, Cerebras and MBZUAI release Jais 2 Arabic LLM"

[21] Middle East AI News. "G42 relaunches Inception with family of 20 open-source Jais AI models"

[22] Hugging Face. "IFM/discarded_samples: Arabic Benchmark Audit dataset"

[23] Hugging Face. "Arabic-Benchmark-Auditing collection (IFM)"

[24] arXiv. "Language Model Tokenizers Introduce Unfairness Between Languages (2305.15425)"

[25] arXiv. "AraDiCE: Benchmarks for Dialectal and Cultural Capabilities in LLMs (2409.11404)"

[26] arXiv. "ArabicMMLU: Assessing Massive Multitask Language Understanding in Arabic (2402.12840)"

[27] arXiv. "Arabic Dialect Identification in the Wild (2005.06557)"

[28] Inception. "Rethinking LLM Evaluation with 3C3H: AraGen Benchmark and Leaderboard"

[29] Hugging Face. "IFM/Jais-3-7B-GGUF model card"

[30] GitHub. "Open Universal Arabic ASR Leaderboard"

[31] arXiv. "The Belebele Benchmark: a Parallel Reading Comprehension Dataset in 122 Language Variants (2308.16884)"

[32] vLLM Recipes. "Jais-3-375B-A23B recipe"

[33] SGLang Cookbook. "Jais 3 deployment recipe"

[34] Hugging Face Papers. "Unlocking Lossless Speedups in LLMs via Discrete Diffusion (2609.04010)"

[35] GitHub. "ifm-ai/uno inference engine"

[36] Hermes AI. "MBZUAI Ships Jais 3, Six Open Arabic Models Beating Qwen and Claude (aggregator)"

[37] RuntimeWire. "MBZUAI's Jais 3 turns Arabic models into agents, from phones to GPU clusters"