Mario-1: an Italian language model that runs on a CPU

Mario-1 is a 0.8-billion-parameter language model built by YecoAI to handle Italian well. Its most concrete feature is that it runs on an ordinary server with no GPU, and answers in seconds. The second is that it does more than generate text: it recognises trick questions, admits when it does not know, holds a multi-turn conversation and does arithmetic reliably.

The problem: small models think in English

Small open models are almost always built for English. Their vocabulary splits Italian badly, and little attention goes to behaviour. The result can be a model that is grammatically perfect and useless in substance: it invents a fact, presents itself as another assistant, falls for a trick question and never admits it does not know.

Mario-1 is built the other way round. Its vocabulary is native Italian, so common words take fewer tokens and answers arrive sooner. Training treats behaviour as part of the work: who it is, what it knows and what it does not know matter as much as the knowledge itself.

How we trained it

Two stages. First, pretraining on an Italian corpus. Then fine-tuning focused on ten areas: mathematics, geography, history, culture, creativity, irony, identity, trick questions, limits and conversation. The hard part, though, was how we chose which version to keep.

• Two exams, not one. Every version is tested on the official question set and on a set of paraphrases. If it only passes the known wordings, it is memorising, not knowing.
• Thresholds set in advance. Each candidate is accepted or rejected against criteria fixed before the experiments, not judged afterwards.
• Contamination check. We compared the training data with the evaluation questions automatically. Part of the historical dataset contained near-duplicates of the test questions, so some earlier scores were too optimistic. We corrected them.

The main finding: the 0.8B ceiling

We tried three ways to improve the release, changing one variable at a time: corrected data mixtures, cleaner data, and shorter training. The result was always the same. Every gain in knowledge cost a drop in behaviour (conversation, identity, limits), and the reverse. This is not a recipe problem: it is the capacity limit of a 0.8B model. That is why the next step needs a larger base model.

CALC: reliable arithmetic without retraining

Small models get arithmetic wrong systematically, and often twice: they miscalculate, then write a number in the answer that differs from their own calculator. CALC fixes both at inference time, at zero cost. Expressions are recomputed in a sandboxed environment and the answer is aligned with the correct result. If a calculation cannot be reconstructed, the number is removed rather than invented. Measured effect: +2 points on the mathematics area, without touching the model.

Internal results

Each area is scored 0-100 on the official set plus paraphrases. The profile is clear: the model is strongest where identity and limits matter, and weaker where creativity and long conversation are needed. The average is about 72.

Against Emma-6, the main Italian competitor

Emma-6 has 1.55 billion parameters, almost twice Mario-1. Mario-1 wins on the ITA-Bench average (39.9 against 37.6) and on BoolQ and Belebele-it. Emma-6 stays ahead on ARC-Challenge, HellaSwag and TruthfulQA, where the gaps are small. Belebele-it is not part of the ITA-Bench average.

Against frontier models of the same class

Qwen2.5-0.5B-Instruct and Llama-3.2-1B-Instruct are reference models for their size, trained on trillions of tokens with budgets estimated in the millions of dollars. Mario-1 beats them on BoolQ and Belebele-it, and trails on the ITA-Bench average, where Qwen2.5 leads.

Serving a small model, for real

A 0.8B model is only useful if it runs everywhere. Mario-1 is optimised for CPU inference: about 30 tokens per second with 4-6 threads and under 1 GB of RAM. Bringing it to production meant resolving subtle differences between frameworks in position handling, the tokenizer and the chat format embedded in the final file. The result is verified: the served model's answers are identical, word for word, to those of our internal reference model.

What it cannot do yet

• Creativity and long conversation are the weakest areas. This is the capacity ceiling described above, not a training flaw.
• Calculations are reliable only for the problem types CALC recognises. Outside those, the model can still get them wrong.
• Long documents remain a weak point: they were not a training goal.
• Knowledge is real but not fully robust to paraphrasing: 93 on the official set, 87 on paraphrases.

What comes next

The whole method built on Mario-1, namely contamination-checked datasets, double evaluation, thresholds fixed in advance and deployment optimisations, moves to the next YecoAI model, built on a larger base model. There, the areas now at the ceiling can grow without sacrificing behaviour.

A small model does not have to be a toy: it has to be honest about what it knows and what it does not know.