Olala-v1.0-mini-7A1B

Olala-v1.0-mini-7A1B is a small reasoning model for chat, instruction following and tool use, built on our hybrid Mamba-3 / attention mixture-of-experts architecture.

  • Made in Europe, open by design: designed in France by OVHai LLM (OVHcloud group), trained on three European supercomputers (JUPITER, Jean Zay and MeluXina) on 12.8T tokens of public datasets and our own synthetic data, and released with open weights under Apache 2.0.
  • Efficient: about 1B active parameters per token, and only 7 of its 36 layers keep a KV cache. It runs on a laptop.
  • Reasoning and agentic: it thinks before it answers, with four reasoning-effort levels, and was trained with reinforcement learning to call tools and to search over many turns.

Find more information in our technical report.

Model details


The Olala-v1.0-mini family includes a base model, the SFT checkpoint, this post-trained model and two specialized models.

Model Description
Olala-v1.0-mini-7A1B-base Pre-trained base model (12.8T tokens)
Olala-v1.0-mini-7A1B-SFT After supervised fine-tuning, before RL
Olala-v1.0-mini-7A1B Final post-trained model: reasoning, chat and tool use
Olala-v1.0-summarise Specialized for document summarization
Olala-v1.0-translate Specialized for machine translation, including financial documents
Property Specification
Checkpoint Post-trained (SFT + reinforcement learning), text-only language model
Parameters 6.8B total, about 1B active per token
Architecture 36 layers: 29 Mamba-3 and 7 attention layers (one in five), each followed by a mixture-of-experts block with 256 routed experts (6 active) and 1 shared expert
Context length 32K tokens (input + output)
A 128K-context version is coming soon.
Vocabulary 151,936 tokens
Training data 12.8T tokens: public datasets and our own synthetic data
Languages Pre-trained on English and 36 other languages (38 in annealing), mostly European, plus Arabic, Chinese, Japanese and Korean (full list in the technical report). Multilingual post-training evaluation covers 11 languages (MGSM) and 8 languages (Multi-IF).
License Apache 2.0
Olala 7A1B architecture: 36 blocks, each a Mamba-3 or differential attention layer followed by a latent mixture-of-experts layer (6 of 256 experts active), with geodesic normalization on the residual stream.

Olala-v1.0-mini-7A1B is designed for reasoning, instruction following, multilingual chat and tool calling.

Inference


Hosted inference

Olala 1.0 mini is served by OVHcloud AI Endpoints (directly, or through your Hugging Face account) and by Blade:

Option Use it for How
OVHcloud AI Endpoints A production API, OpenAI-compatible, hosted in Europe Base URL https://oai.endpoints.kepler.ai.cloud.ovh.net/v1, model Olala-v1.0-mini-7A1B; create an AI Endpoints key for more than a few requests per minute
Hugging Face Inference Providers (ovhcloud) The same AI Endpoints service, with your Hugging Face token and billing The snippet below, or the inference panel on this page
Blade (by Shadow) An OpenAI-compatible API on GPUs in Europe, free to start, with a playground (LLM Studio) Create a key on the Blade console; base URL https://api.models.blade.sh/v1, model olala
OVHcloud AI Deploy Your own GPU: a fine-tuned model, a private deployment Run our pre-built vLLM image ovhaillm/olala-vllm (command below). For a fine-tuned model: AI Deploy guide
Hugging Face Space A demo Call the OVHcloud provider from a Gradio Space (CPU hardware is enough). To run the weights inside a Space, use a Docker Space with our vLLM image ovhaillm/olala-vllm or one of the forks below
Hugging Face Inference Endpoints A dedicated GPU on Hugging Face A custom container with our vLLM image ovhaillm/olala-vllm: the default engines cannot load the olala architecture
import os
from openai import OpenAI

client = OpenAI(base_url="https://huggingface.co/proxy/router.huggingface.co/v1", api_key=os.environ["HF_TOKEN"])
response = client.chat.completions.create(
    model="OVHaiLLM/Olala-v1.0-mini-7A1B:ovhcloud",
    messages=[{"role": "user", "content": "Explain how a heat pump works."}],
    temperature=0.8, top_p=0.9,
)
print(response.choices[0].message.content)

Run it yourself

Ollama, LM Studio and the official llama.cpp, vLLM and mlx-lm cannot load Olala 1.0 mini yet: each option below uses one of our forks. With no installation, use OVHcloud AI Endpoints (see Hosted inference).

You have Use Guide
A Mac with Apple Silicon (M2 or later, 16 GB) MLX, 5.4 GB MLX card
A Mac M1, a PC without GPU, or one NVIDIA GPU for yourself llama.cpp (GGUF), 6 to 14 GB GGUF card
An NVIDIA GPU server (24 GB or more) for an application vLLM, this repo below
Python research code Transformers, this repo below

vLLM (Linux, NVIDIA GPU with 24 GB or more, Python 3.12; tested on L4 and L40S):

git clone https://github.com/OVHai-LLM/vllm.git vllm-fork
VLLM_USE_PRECOMPILED=1 \
VLLM_PRECOMPILED_WHEEL_COMMIT=4135590ffe0119dab806d78a7eee6dff3be2618e \
VLLM_VERSION_OVERRIDE=0.33.0 \
pip install ./vllm-fork

vllm serve OVHaiLLM/Olala-v1.0-mini-7A1B --trust-remote-code \
    --mamba-ssm-cache-dtype float32 \
    --reasoning-parser olala --tool-call-parser olala --enable-auto-tool-choice \
    --max-model-len 32688 --port 8000

Or skip the install with our pre-built image of the same fork, ovhaillm/olala-vllm. Its entrypoint is vllm serve, so the arguments are the model and its options:

docker run --gpus all --ipc=host -p 8000:8000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    ovhaillm/olala-vllm:latest \
    OVHaiLLM/Olala-v1.0-mini-7A1B --trust-remote-code \
    --mamba-ssm-cache-dtype float32 \
    --reasoning-parser olala --tool-call-parser olala --enable-auto-tool-choice \
    --max-model-len 32688

The image is built on CUDA 13.0: it needs an NVIDIA driver 580 or later on the host.

vLLM: always serve this model with --mamba-ssm-cache-dtype float32. vLLM's default keeps the Mamba recurrent state in bf16, and long generations then degrade into repetition loops.

The first start compiles the GPU kernels (about 8 minutes). Then use any OpenAI client on http://localhost:8000/v1:

curl -s http://localhost:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{
  "model": "OVHaiLLM/Olala-v1.0-mini-7A1B",
  "messages": [{"role": "user", "content": "Explain how a heat pump works."}],
  "temperature": 0.8, "top_p": 0.9, "top_k": 40,
  "chat_template_kwargs": {"reasoning_effort": "medium"}
}'

The reply has the reasoning in reasoning_content, the answer in content and tool calls in tool_calls.

Transformers (research code; an NVIDIA GPU, or the CPU). The model code runs in plain PyTorch, so a standard install is enough:

pip install torch "transformers==5.8.*" accelerate einops

Without extra packages, the Mamba-3 layers and the experts run in plain PyTorch: correct, but slow (on the CPU alone, about 6 tokens/s on a 64-core server). For speed, also install the kernels the model code picks up by itself: the Mamba-3 kernels (mamba_ssm) from the mamba fork (branch dev), scattermoe and flash_attn. They compile at install time (flash-attn alone can take an hour); OVHai-LLM/olala-v1 pins a set that works.

from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "OVHaiLLM/Olala-v1.0-mini-7A1B"
tok = AutoTokenizer.from_pretrained(repo, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(repo, trust_remote_code=True, dtype="bfloat16",
                                             device_map="cuda")  # or "cpu" without a GPU (slow)

inputs = tok.apply_chat_template(
    [{"role": "user", "content": "Explain how a heat pump works."}],
    add_generation_prompt=True, reasoning_effort="medium", return_tensors="pt", return_dict=True,
).to(model.device)
out = model.generate(**inputs, max_new_tokens=4096, use_cache=True,
                     do_sample=True, temperature=0.8, top_p=0.9, top_k=40)
print(tok.decode(out[0, inputs["input_ids"].shape[1]:], skip_special_tokens=False))

Keep use_cache=True (the config turns it off) and send one prompt at a time.

Settings. Sampling: temperature=0.8, top_p=0.9, top_k=40 (all scores on this card use them). Reasoning effort, how long the model thinks before answering: disabled, low, medium (default) or high (best for math, slower). Pass it as reasoning_effort to apply_chat_template(), or in chat_template_kwargs in a vLLM request.

Chat template

Olala 1.0 mini writes in channels. Its reasoning goes in an analysis channel, the answer in a final channel and tool calls in a tools channel:

<|im_start|>assistant<|channel_start|>analysis<|content|>...reasoning...<|channel_end|><|channel_start|>final<|content|>...answer...<|channel_end|><|im_end|>

Use tokenizer.apply_chat_template() with add_generation_prompt=True to format messages automatically. The template starts with a built-in system prompt; a system message you pass is added after it as developer instructions.

Reasoning is enabled by default (medium). With reasoning_effort="disabled", the template closes the analysis channel empty and the model answers directly.

Reasoning from earlier assistant turns is removed unless preserve_thinking=True.

Tool calling

Pass function schemas through tools=... to apply_chat_template() (or tools in the OpenAI-compatible API with the vLLM tool parser). Generated calls are XML with JSON arguments, in the tools channel:

<toolcalls><call id="call_0"><name>get_weather</name><arguments>{"city": "Paris"}</arguments></call></toolcalls>

Several independent calls can share one <toolcalls> block. Execute the calls in your application, add the assistant message with its tool_calls to the history, then append each result as a tool message with its tool_call_id. Keep passing the tool schemas on later requests.

Examples


Two small repos show Olala 1.0 mini working with tools through any OpenAI-compatible endpoint:

  • olala-mini-tools: answer questions about a database in SQL, pick the right connector (CRM, mail, calendar) and fill in its parameters, classify incoming messages. In French and English.
  • choose-the-right-beam: an engineering task with three tools (a catalogue in SQL, calculations in Python, project notes). The model reads and writes; the code checks each step. In French.

Fine-tuning


To adapt Olala 1.0 mini to your own data, use the ready-to-run fine-tuning image on Docker Hub (x86-64, one NVIDIA H100). It trains a LoRA adapter on Olala-v1.0-mini-7A1B and merges it into a complete model. You write no training code: you give a file of examples and run one job.

Step by step on OVHcloud: fine-tune with AI Training (en français), then deploy the fine-tuned model with AI Deploy (en français).

Each line of the training file is one conversation. The model learns to produce the assistant turn:

{"messages": [{"role": "system", "content": "You are the support assistant of an online shop. Classify the customer message into one of these categories: delivery, refund, product, account. Answer with the category only."}, {"role": "user", "content": "I still haven't received the order I placed last week."}, {"role": "assistant", "content": "delivery"}], "chat_template_kwargs": {"reasoning_effort": "disabled"}}

"reasoning_effort": "disabled" makes the model answer directly. Put a few thousand examples in data/train.jsonl and a few hundred others in data/eval.jsonl, then run (tested with the image's command on one H200, the same Hopper generation as the H100; 1,000 examples train in about 7 minutes):

mkdir -p model data out && chmod 0777 model data out   # the image runs as UID 42420
docker run --gpus all --rm \
  -v "$PWD/model:/workspace/model" \
  -v "$PWD/data:/workspace/data" \
  -v "$PWD/out:/workspace/out" \
  -e DOWNLOAD_DATA=0 \
  -e TRAIN_FILE=/workspace/data/train.jsonl \
  -e EVAL_FILE=/workspace/data/eval.jsonl \
  -e SKIP_BENCH=1 \
  ovhaillm/olala-ai-training:20261117

The first run downloads the model into model/ (about 14 GB); later runs reuse it. The complete fine-tuned model is written to out/merged/, next to the adapter (out/adapter/). Serve it with vLLM as shown above, or with the ovhaillm/olala-ai-deploy image on one L4 GPU (tested).

No data yet? Run the same command without the -e options: the job downloads a public English↔French dataset from the European Central Bank, fine-tunes the model on it, and scores the translations (BLEU, chrF++) before and after.

Performance


Benchmarks

Over twelve benchmarks, Olala-v1.0-mini-7A1B averages 68.0, 15.2 points above its SFT checkpoint. It is strongest on instruction following and weakest on competition mathematics.

The table shows all 19 models we evaluated, grouped by size. Scores in %; bold is the best score on each benchmark, underlined the second best.

Ours 7-8B MoE, ~1B active Up to 2B dense 2.6-4B dense 7-9B dense 23B dense
Benchmark Olala
v1.0-mini-7A1B

7B-A1B
Granite
4.0-H-Tiny
7B-A1B
LFM2.5
8B-A1B
8B-A1B
Ling
3.0-tiny
7.9B-A1.3B
OLMoE
1B-7B-Instruct
7B-A1B
LFM3-1.7B
1.7B
Qwen3.5-2B
2B
LFM2.5
2.6B
2.6B
Ministral
3-3B-Reasoning
3B
Qwen3.5-4B
4B
SmolLM3-3B
3B
Apertus
8B-Instruct
8B
EuroLLM
9B-Instruct
9B
Falcon
H1R-7B
7B
Ministral
3-8B-Reasoning
8B
Mistral
7B-Instruct-v0.3
7B
Olmo
3-7B-Think
7B
Luciole
23B-Instruct
23B
Luciole
23B-Thinking
23B
Instruction following
IFBench 57.7 14.3 48.3 57.3 17.0 70.0 35.3 59.0 33.7 49.7 19.0 19.3 15.0 45.3 27.0 18.0 38.7 26.3 23.7
Multi-IF 71.2 44.5 71.0 75.2 25.0 83.6 57.3 77.7 48.6 71.8 42.9 41.8 37.7 65.7 49.7 25.5 61.2 51.6 54.6
LIFEBench 79.3 63.4 77.8 82.3 51.0 82.7 82.0 79.3 68.4 84.0 64.6 62.4 64.0 72.1 72.8 58.2 71.1 61.5 64.3
Knowledge and reading
GPQA Diamond 50.5 30.3 41.9 68.7 15.7 62.6 63.1 56.1 42.4 75.8 42.9 23.7 30.3 62.1 56.6 21.2 48.5 28.8 36.4
TruthfulQA 66.6 48.7 68.9 66.5 12.7 65.6 60.5 62.9 47.7 74.7 59.9 21.7 47.4 67.3 63.4 8.0 65.6 57.6 64.3
DROP 83.8 64.7 73.1 87.6 36.4 85.5 81.4 79.6 82.2 86.3 54.0 55.0 62.5 85.7 85.6 35.8 86.7 63.4 78.7
Code
HumanEval+ 88.3 77.4 79.9 92.0 32.4 92.2 48.3 90.2 92.6 83.4 81.3 34.6 36.0 93.4 93.8 32.8 91.1 44.1 77.4
MBPP+ 75.1 72.8 64.2 79.1 26.0 80.8 49.0 74.9 78.5 73.5 70.8 44.3 48.6 82.0 81.0 45.7 79.0 62.6 71.7
Math
AIME 2024 60.7 4.0 64.7 78.7 0.7 81.3 24.0 66.7 74.7 80.7 46.0 0.0 0.0 94.0 78.0 0.0 69.3 10.0 30.0
AIME 2025 61.3 4.7 48.0 70.0 0.0 79.3 26.7 51.3 70.0 74.7 32.7 0.0 0.7 82.7 78.0 0.0 64.0 13.3 31.3
AIME 2026 52.7 10.0 48.0 75.3 0.0 80.0 27.3 57.3 73.3 82.0 45.3 0.7 0.7 90.0 82.7 0.0 67.3 6.0 23.3
MGSM 68.7 62.0 60.5 73.7 22.0 79.3 73.3 75.7 77.7 88.8 61.7 40.7 39.8 66.9 84.8 28.7 71.7 45.9 61.0
Tool use
BFCL V3 59.6 60.2 69.7 68.3 n/a 74.1 59.2 67.9 37.7 67.8 42.6 n/a n/a 67.8 42.0 48.2 n/a 60.4 35.1

Luciole-23B-Thinking is an interim checkpoint that is not publicly released. OLMoE-1B-7B has a 4,096-token context window; prompts that do not fit count as wrong. n/a: the model has no native tool-call support.

Evaluation details

We ran every model ourselves, on the same cluster and with the same evaluation code (inspect_ai querying a vLLM server). Each model uses its own chat template, zero-shot, with the sampling parameters from its model card and with reasoning enabled when it has it. Every model gets the same context window and no separate limit on answer length. Olala 1.0 mini models use temperature=0.8, top_p=0.9, top_k=40, reasoning_effort="high" and a float32 Mamba state.

HumanEval+, MBPP+ and AIME: pass@1 averaged over 5 samples per problem. The other benchmarks use one sample per question.
MGSM: 11 languages.
Multi-IF: three turns, eight languages, prompt-level strict accuracy averaged over turns and languages.
LIFEBench: answers of a requested length.
BFCL V3: all 23 categories (4,981 samples). n/a: the model has no native tool calling.
Average: unweighted mean of the 12 other benchmarks. BFCL V3 is left out because some models cannot be scored on it.

Safety

We tested the SFT checkpoint and the final model on 5,701 attack prompts and 299 benign prompts. Reinforcement learning roughly halves the attack success rate. It also makes the model refuse more benign requests and hit the token limit more often while reasoning. Lower is better on every row.

Olala-v1.0-mini-7A1B-SFT Olala-v1.0-mini-7A1B
Attacks (n = 5,701)
Guard attack success rate (%) ↓ 12.5 6.3
Guard attack success rate, strict (%) ↓ 24.6 13.5
Harmful, rubric judge (%) ↓ 34.9 22.2
Benign (n = 299)
Over-refusal (%) ↓ 7.0 10.7
All prompts
Reasoning overflow (%) ↓ 11.8 15.0

Training


Olala pre-training mix: main pre-training on 10.4T tokens (English web 41%, multilingual 41%, code 9%, mathematics 5%, translation 4%), then annealing on 2.38T tokens (mathematics 36%, multilingual 23%, code 19%, English 13%, instructions 8%).

Pre-training: two phases build Olala-v1.0-mini-7A1B-base on 12.8T tokens: a main pre-training on 10.4T tokens (web in English and 36 other languages, code, mathematics, translation pairs), then an annealing on 2.38T tokens where mathematics becomes the largest share and instruction data is added. The training data is described on the base model card.

Olala 1.0 mini was trained on three European supercomputers: JUPITER (Germany), Jean Zay (France) and MeluXina (Luxembourg). The base model was pre-trained on 1,024 GH200 GPUs of JUPITER. Its training emitted about 40 t CO₂e (market-based): see Environmental impact.

Olala post-training: the base model goes through supervised fine-tuning, then a reinforcement learning cascade of four stages (instruction following and math, code, assistant behaviour, agentic), giving Olala-v1.0-mini-7A1B.

Post-training: supervised fine-tuning, then reinforcement learning in four stages.

  • Supervised fine-tuning (SFT): 36.9M samples from 27 datasets (about 162B tokens) teach the model to follow the chat template, reason before it answers at four effort levels, call tools and act as an agent. The data covers general chat and instruction following, mathematics and science, code, multilingual tasks, agentic traces and safety.
  • Reinforcement learning: a cascade of four stages. Each stage trains one family of tasks and starts from the end of the previous one.
    1. Instruction following and math, with knowledge, science, multilingual, safety and tool-calling prompts.
    2. Code: competitive programming and function-level problems checked by running tests.
    3. Assistant behaviour: tool use, safety, honesty and conversation quality.
    4. Agentic: the model calls tools, reads their results and searches over up to 75 turns.

Environmental impact

Training

Energy About 1.16 GWh for the whole training: pre-training and annealing on JUPITER (1,024 GH200 GPUs, Germany), supervised fine-tuning and reinforcement learning on Jean Zay (H100 GPUs, France) and MeluXina (Luxembourg)
Emissions About 40 t CO₂e (range 30 to 50 t), market-based: electricity covered by renewable supply contracts
Largest share JUPITER, about 70% of the emissions

Inference (Boavizta method, whole machine, electricity in France and hardware manufacturing; est. = estimated, other values measured in November 2026)

Machine Load g CO₂e per million generated tokens
Server with an H100 GPU 32 or more requests at once 12 (est.)
Laptop (MacBook M1 Pro) one request at a time 30
PC with 8 GB of RAM and no GPU one request at a time 65 (est.)
Server with an H100 GPU one request at a time 140 (est.)

Load matters more than hardware: a busy H100 server emits about ten times less per token than one serving a single request. For a single user, a laptop or a PC without a GPU is the low-carbon option.

Method: training emissions are energy × the carbon intensity of each site's electricity supply contract (market-based). Inference: Boavizta API 2.6, French grid 0.098 kg CO₂e/kWh, PUE 1.2, manufacturing share for the time used.

Uses and limitations


Intended uses

Olala-v1.0-mini-7A1B is a general-purpose text model for developers who build it into their own applications:

  • assistants and chat, with instruction following, in English and the main European languages;
  • agents and workflows that call tools: databases, APIs, search, code execution;
  • reasoning in mathematics, science and code, with an adjustable reasoning effort;
  • local and on-premises deployment, when data must stay on your own machines.

Out of scope

  • Uses prohibited by law, including the practices banned by Article 5 of the EU AI Act.
  • Decisions with legal or similarly significant effects on people (credit, employment, insurance, education, health, justice, access to public services) without review by a qualified person.
  • Answering from memory where accuracy matters: facts, figures, legal, medical or financial information. Give the model the source, or a tool to read it.
  • Images, audio or any other input than text.

Limitations

  • Knowledge: with about 1B active parameters, it stores less factual knowledge than larger models and can state wrong facts with confidence. It was trained to read data through tools rather than answer from memory: give it those tools.
  • One job per request: it does best on short, single-purpose requests. For longer work, chain short requests in your code and check each step, as in choose-the-right-beam.
  • Languages: its comprehension outside English and the main European languages is weaker than its training mix suggests. Test it on your language before you rely on it.
  • Mathematics: of the benchmarks above, competition mathematics is its weakest area.
  • Context: 32K tokens, input and output together.
  • Repetition: a long reasoning can fall into a repetition loop. Use the recommended sampling parameters, set a token limit, and on vLLM always serve it with --mamba-ssm-cache-dtype float32.
  • Quantization: generic quantization recipes produce NaN on realistic inputs. Use the GGUF and MLX files we publish, or follow their recipe.
  • Long prompts on CPU take a long time to process. Prefer a GPU for long documents.
  • No clock: it does not know today's date. Give it the date when it matters.
  • Knowledge cut-off: its pre-training data goes up to January 2026 (post-training data up to April 2026), so it does not know about later events.
  • Bias and safety: it can reproduce biases present in web data and can produce inaccurate or harmful content despite its safety training: in our tests, 6.3 % of attack prompts still succeeded (see Safety), and it refuses about 1 benign request in 10. Add safeguards suited to your application: input and output filters, human review.

Responsibilities

If you modify this model substantially, or place a system built on it on the market under your own name, you may become a provider under the EU AI Act, with the obligations that come with it, including those for high-risk AI systems when your use case is listed in Annex III.

Before you deploy: read the public summary of training content and our copyright policy.

License


Licence Apache License, Version 2.0 (SPDX: Apache-2.0)
Licensor OVH LLM SAS, trading as OVHai LLM, 2 rue Kellermann, 59100 Roubaix, France
Copyright Copyright 2026 OVH LLM SAS
Release date 19 November 2026
Distribution Open weights
Notices NOTICE: keep it when you redistribute the model or a derivative. It includes the attribution of the Qwen tokenizer (Copyright 2024 Alibaba Cloud, Apache 2.0)
Training content (EU AI Act) Public summary of training content, on the European Commission template (Art. 53(1)(d))

Citation


@techreport{ovhaillm2026olala,
  title       = {Olala v1.0 mini Technical Report},
  author      = {{OVHai LLM Research Team}},
  institution = {OVHcloud},
  year        = {2026},
  url         = {https://huggingface.co/OVHaiLLM/Olala-v1.0-mini-7A1B/blob/main/Olala-v1.0-mini.pdf},
}
Downloads last month
1,517
Safetensors
Model size
7B params
Tensor type
F32
·
BF16
·
Inference Providers NEW
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Model tree for OVHaiLLM/Olala-v1.0-mini-7A1B

Finetuned
(1)
this model
Finetunes
2 models
Quantizations
4 models

Space using OVHaiLLM/Olala-v1.0-mini-7A1B 1

Collection including OVHaiLLM/Olala-v1.0-mini-7A1B