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.
Find more information in our technical report.
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-v1.0-mini-7A1B is designed for reasoning, instruction following, multilingual chat and tool calling.
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://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)
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.
[!IMPORTANT] 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.
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.
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.
Two small repos show Olala 1.0 mini working with tools through any OpenAI-compatible endpoint:
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).
[!TIP] No data yet? Run the same command without the
-eoptions: 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.
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 detailsWe 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.
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 |
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.
Post-training: supervised fine-tuning, then reinforcement learning in four stages.
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.
Olala-v1.0-mini-7A1B is a general-purpose text model for developers who build it into their own applications:
--mamba-ssm-cache-dtype float32.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.
| 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)) |
@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},
}