Olala-v1.0-mini-7A1B-SFT is the supervised fine-tuning checkpoint of Olala-v1.0-mini-7A1B, before alignment (reinforcement learning). It follows the chat template, reasons before it answers at four effort levels and calls tools.
[!WARNING] Pre-alignment checkpoint, toxic: do not use it as an assistant or expose it to end users. It comes before the alignment stage (reinforcement learning for safety and helpfulness). It can produce toxic, hateful or harmful content, and it complies with harmful requests far more often than the final model: in our tests, 12.5 % of attack prompts succeeded (6.3 % for the final model) and 34.9 % of its answers to attacks were judged harmful (see Safety). Use it only for research and further training, with your own safety training and filters. For an assistant, use Olala-v1.0-mini-7A1B.
Find more information in our technical report.
The Olala-v1.0-mini family includes a base model, this SFT checkpoint, the post-trained model and two specialized models.
| Model | Description |
|---|---|
| Olala-v1.0-mini-7A1B-base | Pre-trained base model (12.8T tokens). Not aligned: research and fine-tuning only |
| Olala-v1.0-mini-7A1B-SFT | After supervised fine-tuning, before alignment (RL); can be toxic: research and fine-tuning only |
| 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 | Supervised fine-tuned, text-only language model (no reinforcement learning) |
| 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 |
Choose a checkpoint variant for your inference framework and hardware.
Upstream vLLM, llama.cpp, mlx-lm, Ollama and LM Studio do not support the olala architecture yet. Use the forks
above.
Sampling parameters: temperature=0.8, top_p=0.9, top_k=40. All the scores on this card use them.
Reasoning effort: disabled, low, medium (default) or high. It is a chat-template argument
(reasoning_effort=... in apply_chat_template()). In vLLM, pass it inside chat_template_kwargs: "chat_template_kwargs": {"reasoning_effort": "high"}, not the top-level reasoning_effort request parameter. The benchmarks on this card use high.
[!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.
vLLM quick start:
# vLLM fork with Olala support, based on vLLM 0.33 (the reasoning and tool-call parsers are built in)
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-SFT \
--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
curl -s http://localhost:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{
"model": "OVHaiLLM/Olala-v1.0-mini-7A1B-SFT",
"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 parsers return the reasoning in reasoning_content, the answer in content and tool calls in tool_calls.
The decode kernels are JIT-compiled CUDA with fast paths for Hopper (H100, H200) and Ada (L4, L40S) GPUs: about
85 tokens/s for a single request on an L4. The first start compiles them and takes a few minutes. --max-model-len must be a multiple of 144 (the attention block size).
Transformers quick start:
Requirements: 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-SFT"
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)
messages = [{"role": "user", "content": "Explain how a heat pump works."}]
inputs = tok.apply_chat_template(
messages, 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))
use_cache=True: config.json sets use_cache: false, and without the cache every new token recomputes
the whole sequence.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.
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 fine-tunes Olala-v1.0-mini-7A1B with LoRA and writes a complete model. The data format and the commands are in the Fine-tuning section of the Olala-v1.0-mini-7A1B card.
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).
Olala-v1.0-mini-7A1B-SFT against the final post-trained model. Reinforcement learning adds 15.2 points on average, with the largest gains in mathematics, instruction following and tool calling.
| Benchmark | Olala v1.0-mini-7A1B-SFT 7B-A1B |
Olala v1.0-mini-7A1B 7B-A1B |
|---|---|---|
| Code | ||
| HumanEval+ | 75.1 | 88.3 |
| MBPP+ | 68.3 | 75.1 |
| Math | ||
| AIME 2024 | 36.0 | 60.7 |
| AIME 2025 | 28.7 | 61.3 |
| AIME 2026 | 29.3 | 52.7 |
| MGSM | 61.6 | 68.7 |
| Knowledge and reading | ||
| GPQA Diamond | 37.9 | 50.5 |
| DROP | 78.0 | 83.8 |
| TruthfulQA | 60.1 | 66.6 |
| Instruction following | ||
| IFBench | 33.0 | 57.7 |
| Multi-IF | 50.9 | 71.2 |
| LIFEBench | 74.5 | 79.3 |
| Tool use | ||
| BFCL V3 | 38.3 | 59.6 |
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.
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.
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.
| Data group | Share of tokens |
|---|---|
| Science (math and STEM) | 46.4% |
| General (chat, multi-turn, instruction following) | 41.8% |
| Code (code and structured output) | 7.8% |
| Agentic (agents and tool calling) | 2.3% |
| Multilingual (multilingual and translation) | 1.7% |
| Safety (toxicity and hallucinations) | <0.1% |
| Total | 100% |
These figures cover the whole training of Olala 1.0 mini. This checkpoint is one of its stages (pre-training, annealing and supervised fine-tuning); the split by stage is not published.
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 |
Method: training emissions are energy × the carbon intensity of each site's electricity supply contract (market-based).
This is the supervised fine-tuning checkpoint, before reinforcement learning, for research and further training (for example preference optimization or domain fine-tuning).
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},
}
OVHaiLLM/Olala-v1.0-mini-7A1B-base