Italian language LLM: state of the art 2026

Which Italian language model to choose: the answer depends on the license

If you need an open language model for Italian, the first question is not "which one is better?" but "what am I allowed to do with it?". Among the most cited Italian models, one is trained from scratch with open data and weights (Minerva), one has an MIT license on the file but separate terms of use (Modello Italia), one is adapted from Mistral with an Apache 2.0 license (Cerbero), one is declared for research only (Camoscio). Choosing on the scores without looking at this means risking building a product that you cannot distribute.

This article reports no rankings. It reports what can be checked: what each model card declares, and how to read it with a program that you can rerun. For the historical picture read Italian LLMs in 2024 and the 2025 landscape.

Three ways to get to a model that speaks Italian

Imagine having to get a new colleague to write in Italian. You can hire someone who grew up in Italy, you can take a good foreign colleague and have them take a language course, or you can simply have them translate the work. Models follow the same roads. Cost, quality and, above all, what they inherit from the starting point change: license, limits and flaws.

• Training from scratch on Italian: Minerva (Sapienza NLP with FAIR and CINECA) and Modello Italia (iGenius with CINECA).
• Continuing the training of a foreign model: Cerbero starts from Mistral 7B, LLaMAntino-3 from Llama 3 8B.
• Adapting with little compute: Camoscio applies LoRA to LLaMA 7B with instructions translated into Italian.

The list is ordered from the most expensive to the cheapest, and the order changes the meaning: whoever starts from scratch decides the data but has to pay months of compute; whoever adapts pays little but inherits the license and any limits of the starting model. For a small company, the realistic road is almost always the second or the third, and that is why the license of the base model weighs more than the quality in Italian.

What each model declares

The information below comes from the public cards (the "model cards") and from the authors' repositories, consulted on 2026-11-12. Where the card itself warns that a piece of data is not official, I say so.

• Modello Italia 9B: iGenius's first model, in collaboration with CINECA. The weights on the Hub are an unofficial conversion of the official checkpoint, with an MIT license label, but use requires accepting iGenius's terms and conditions. According to the card, the training data are unknown.
• Minerva 7B: the "pretrained from scratch on Italian" family from Sapienza NLP with FAIR and CINECA; the 7B card indicates almost 2.5 trillion tokens (1.14 trillion in Italian, 1.14 in English, 200 billion of code), Apache 2.0 license.
• Cerbero 7B: built on Mistral 7B, Apache 2.0 license, declared by the authors as usable in commercial settings too; described in the paper "Cerbero-7B: A Leap Forward in Language-Specific LLMs Through Enhanced Chat Corpus Generation and Evaluation".
• Camoscio 7B: LLaMA adapted with LoRA on the Stanford Alpaca dataset translated into Italian with the ChatGPT API; the card intends it for research and states that production use is not permitted.
• LLaMAntino-3 ANITA 8B: derived from Meta Llama 3 8B Instruct, with the license label llama3, hence subject to Meta's license.

The thread that ties the items together is that the most important line is not the one on performance, but the one on the license and the origin of the data. Two cases deserve attention. The first is Modello Italia: the MIT label describes the conversion, while iGenius's conditions remain a separate constraint, and it is a distinction that an automatic license check does not catch. The second is Camoscio: it comes from the answers of another model (the instructions translated with ChatGPT), and the terms of use of that service may limit what you get out of it. For commercial uses, read the original texts and, if needed, ask for legal advice: this article does not replace it.

Reading the cards with a program, not from memory

The cards change: a model is withdrawn, a license is updated. If you write in a document "Cerbero is Apache 2.0" and never reread it, the document ages. The program below queries the public Hugging Face Hub API (described in the Hub API documentation) and prints the declared license, base model and architecture. It uses only the Python standard library: no PyTorch, no token, no download of the weights.

import json
import urllib.request

MODELLI = [
    "sapienzanlp/modello-italia-9b",
    "sapienzanlp/Minerva-7B-base-v1.0",
    "galatolo/cerbero-7b",
    "teelinsan/camoscio-7b-llama",
    "swap-uniba/LLaMAntino-3-ANITA-8B-Inst-DPO-ITA",
]

def scheda(modello):
    url = "https://huggingface.co/api/models/" + modello
    with urllib.request.urlopen(url, timeout=20) as risposta:
        dati = json.load(risposta)
    carta = dati.get("cardData") or {}
    config = dati.get("config") or {}
    return {
        "modello": modello,
        "licenza": carta.get("license", "non dichiarata"),
        "base": carta.get("base_model", "non dichiarata"),
        "architettura": config.get("model_type", "non indicata"),
        "creato": (dati.get("createdAt") or "")[:10],
    }

for m in MODELLI:
    print(scheda(m))

# Actual output (python3 -I schede.py, 2026-11-12):
# {'modello': 'sapienzanlp/modello-italia-9b', 'licenza': 'mit', 'base': 'non dichiarata', 'architettura': 'gpt_neox', 'creato': '2024-06-06'}
# {'modello': 'sapienzanlp/Minerva-7B-base-v1.0', 'licenza': 'apache-2.0', 'base': 'non dichiarata', 'architettura': 'mistral', 'creato': '2024-05-26'}
# {'modello': 'galatolo/cerbero-7b', 'licenza': 'apache-2.0', 'base': 'non dichiarata', 'architettura': 'mistral', 'creato': '2023-10-26'}
# {'modello': 'teelinsan/camoscio-7b-llama', 'licenza': 'openrail', 'base': 'non dichiarata', 'architettura': 'non indicata', 'creato': '2023-03-24'}
# {'modello': 'swap-uniba/LLaMAntino-3-ANITA-8B-Inst-DPO-ITA', 'licenza': 'llama3', 'base': 'meta-llama/Meta-Llama-3-8B-Instruct', 'architettura': 'llama', 'creato': '2024-04-29'}

The lines that matter are those inside scheda(). cardData is the block of metadata written by the author in the card; config is the model's configuration file, from which model_type is read. The default value of .get() (here "non dichiarata", that is "not declared") avoids an error when the field is missing, and makes the absence visible. If you remove the timeout, a slow Hub blocks the program without messages. The names in the code and in the output are Italian, as in the real run: modello is the model, licenza the license, base the base model, architettura the architecture, creato the creation date, and "non indicata" means "not stated".

In the output you can see that the architecture does not always coincide with the origin: Minerva shows up as mistral as a model type, but it is trained from scratch, that is it uses Mistral's architecture, not its weights. In the same way, the base field is "non dichiarata" for Cerbero, even though the card says in text that it is built on Mistral 7B: the metadata are incomplete, so an automatic check alone is not enough. Moreover the "creato" column is the creation date of the repository, not of the model's publication: Modello Italia appears as 2024-06-06 because the conversion was uploaded that day.

What the numbers say, and why we do not compare them

The cards report results, but each with its own benchmark, version and method. The Modello Italia card indicates an average result of 0.4350 on three tests in Italian (hellaswag_it, arc_it, m_mmlu_it) and points to the Open Italian LLM Leaderboard. The Cerbero card reports, for its SQuAD-it benchmark (reading comprehension of a text), an F1 of 72.55% against Camoscio's 37.42%. These are numbers declared by the authors, on different tests: putting the two values in the same table would give the impression of a comparison that does not exist.

To decide on your case, the best benchmark is a hundred examples of your own: questions that your users really ask, with the expected answer. A model that wins on SQuAD-it can get your invoices wrong. How to build that evaluation you find in Fine-tuning an LLM for Italian, and for the cases where you need your own documents look at RAG in Italian, which often avoids fine-tuning.

Loading a model: what you need and what can go wrong

The code below is the example from the Modello Italia card, with my comments. I did not run it: it requires PyTorch and a computer with a lot of memory, and the machine on which I prepared the article has neither. Take it as a scheme to try, not as guaranteed output.

import torch
import transformers as tr

device = "cuda" if torch.cuda.is_available() else "cpu"

tokenizer = tr.AutoTokenizer.from_pretrained("sapienzanlp/modello-italia-9b")
model = tr.AutoModelForCausalLM.from_pretrained(
    "sapienzanlp/modello-italia-9b",
    device_map=device,
    torch_dtype=torch.bfloat16,
)

messages = [
    {"role": "system", "content": "Tu sei Modello Italia, un modello di linguaggio naturale addestrato da iGenius."},
    {"role": "user", "content": "Ciao, chi sei?"},
]
tokenized_chat = tokenizer.apply_chat_template(
    messages, tokenize=True, add_generation_prompt=True, return_tensors="pt"
).to(device)

AutoTokenizer and AutoModelForCausalLM come from Hugging Face's transformers library; the first turns text into numbers, the second is the model that predicts the next word. The line that weighs is torch_dtype=torch.bfloat16: each parameter takes 2 bytes instead of 4, and for a model of about 9 billion parameters that makes about 18 GB for the weights alone (9 billion times 2 bytes, my own calculation, not counting working memory). Without that line, loading would use double and on many graphics cards it would stop with an out-of-memory error.

apply_chat_template builds the text in the format the model saw in training: the "system" role sets the behavior, "user" is the question. The two messages stay in Italian, as in the model card, because the model is for Italian: the system message says "You are Modello Italia, a natural language model trained by iGenius", and the user asks "Hi, who are you?". If you pass a free-form prompt without this format, the answer gets worse in ways that are hard to explain. With device = "cpu" the code works but is very slow for a model of this size: on your work computer, a smaller model (Minerva has versions of 350 million, 1 and 3 billion parameters, listed on its card) is the most sensible starting point for trying. And remember that, for Modello Italia, using the weights means accepting iGenius's conditions.

How to decide, in short

Start from the use. If the model has to sit in a product you sell, first discard whatever has no clear license for commercial use (Camoscio) or depends on separate conditions (Modello Italia, LLaMAntino with the Llama 3 license). Among what remains, Minerva has open data and model, while Cerbero has an origin in Mistral and a permissive license. With equal licenses, the test with your hundred examples decides. For research and for learning, instead, all of them are fine, and that is exactly where Camoscio was born.

What you can do now

You can tell apart the three ways in which a model becomes "Italian" and what each one inherits. You can read the license and origin of a model with a program you can rerun, and you know that metadata can be incomplete. You know why a benchmark percentage is not enough, and how to build your own comparison. And you can estimate by hand the memory for the weights of a model before downloading it.

Sources

• Card of sapienzanlp/modello-italia-9b on Hugging Face - unofficial conversion of Modello Italia, MIT license, iGenius conditions, GPT-NeoX architecture (unofficial), average results, loading example, consulted on 2026-11-12
• Card of sapienzanlp/Minerva-7B-base-v1.0 on Hugging Face - training from scratch, tokens per language, Apache 2.0 license, sizes of the family, consulted on 2026-11-12
• Card of galatolo/cerbero-7b on Hugging Face - Mistral 7B base, Apache 2.0 license, SQuAD-it results declared by the authors, consulted on 2026-11-12
• Cerbero-7B: A Leap Forward in Language-Specific LLMs Through Enhanced Chat Corpus Generation and Evaluation (arXiv 2311.15698) - the model's paper, consulted on 2026-11-12
• Camoscio repository on GitHub - LoRA on LLaMA, Alpaca dataset translated with ChatGPT, use limited to research; the associated paper is arXiv 2307.16456, consulted on 2026-11-12
• Hugging Face Hub: API - the endpoint used by schede.py, consulted on 2026-11-12
• Measurement in the repository: python3 -I schede.py, output reported above, run on 2026-11-12

The loading block with transformers was not run (no PyTorch on the work machine), and the information on LLaMAntino-3 comes from the Hub metadata, not from a full reading of its card.