DEV Community

Cover image for OVHcloud Olala Mini 7A1B: Europe's Laptop LLM
Muhammad Saud
Muhammad Saud

Posted on Originally published at logicstack.org

OVHcloud Olala Mini 7A1B: Europe's Laptop LLM

Olala Mini 7A1B is OVHcloud's first open-weight language model, released on 19 November 2026. It has 6.8 billion parameters but activates only about 1 billion per token, so it runs on a laptop or an 8 GB graphics card. It matters for European developers because the weights, the training recipe and the EU AI Act paperwork are all public, under Apache 2.0.
Key takeaways

  • Olala Mini 7A1B has 6.8 billion total parameters with about 1 billion active per token, a 32K context window, and Apache 2.0 open weights.
  • OVHcloud's own benchmarks average 68.0 across 12 tests, with HumanEval+ at 88.3. No independent lab has reproduced them yet.
  • About 70 tokens per second on a 16 GB MacBook Air M5 with the 6-bit GGUF build, per OVHcloud.
  • Upstream Ollama, LM Studio, llama.cpp, vLLM and mlx-lm cannot load it yet. You need one of OVHcloud's forks, or the hosted API.
  • The hosted API is OpenAI compatible and runs in Europe, so the fastest first test needs no install at all.

What is Olala Mini 7A1B?

Olala Mini 7A1B is the first model from OVHai LLM, the in-house AI lab of OVHcloud, the French cloud provider. Announced on 17 November 2026, the weights landed two days later at the company's AI Summit in Paris, with a technical report and EU AI Act documentation. A team of about 100 people built it on European infrastructure, not a fine-tune of someone else's weights.

Training ran on three European supercomputers: JUPITER in Germany, Jean Zay in France and MeluXina in Luxembourg. The model saw 12.8 trillion tokens, in English and 36 other languages, mostly European. Most small open models are trained mainly on English and Chinese, so that multilingual base is a real differentiator.

The architecture is a hybrid: 36 layers, 29 Mamba-3 and 7 attention, each followed by a mixture-of-experts block with 256 routed experts, 6 active per token, plus 1 shared expert. Only 7 of the 36 layers keep a KV cache, so the model is cheap to run: the Mamba layers carry state without the growing memory cost of attention, and most parameters sit idle on any given token.

Five checkpoints shipped: a base model, an SFT checkpoint, the final post-trained model, and two specialists for summarisation and translation. The final model is the one to use as an assistant. It was trained with reinforcement learning to reason before answering, call tools, and search over many turns, with four reasoning effort levels: disabled, low, medium and high.

How fast is it, and what do the benchmarks actually say?

OVHcloud's boldest claims are about speed: 160 tokens per second on an RTX A4500, about 50 on a standard CPU, and about 70 on a 16 GB MacBook Air M5 with the 6-bit GGUF build. Those are vendor numbers with no independent measurements yet, but the architecture makes them plausible: 1 billion active parameters is little maths per token, and the small KV cache keeps memory bandwidth low.

OVHcloud ran its own evaluation across 12 tests, scoring Olala and 18 rivals on the same cluster with the same code. Olala averages 68.0 and ranks seventh of nineteen. Reinforcement learning added 15.2 points on average over the SFT checkpoint, with the largest gains in maths, instruction following and tool calling.
BenchmarkOlala Mini 7A1BWhat it measuresHumanEval+88.3Python codingMBPP+75.1Programming problemsIFBench57.7Output constraintsMulti-IF71.2Multilingual instruction followingGPQA Diamond50.5Graduate scienceTruthfulQA66.6TruthfulnessAIME 202652.7Competition mathsBFCL V359.6Tool calling
Read the table with the vendor caveat attached: these are OVHcloud's own figures, and no independent lab has reproduced them yet. The pattern is still useful, because the company is candid about the weak spots. Olala is strongest at following instructions and writing code, and weakest at competition maths and graduate science. On GPQA Diamond it scores 50.5, while Qwen3.5 4B reaches 75.8, and Qwen3.5 4B beats Olala on nine of the twelve tests. But its IFBench score of 57.7 is roughly double Mistral's Ministral 3 8B, and it beats European rivals such as EuroLLM 9B and Apertus 8B by a wide margin.

OVHcloud even withdrew its Q4_K_M GGUF file after testing showed it was measurably worse for only 0.3 GB saved, with MBPP+ falling to 67.7. The 8-bit, 6-bit and 5-bit files all score within noise of the BF16 original, with a standard error of 2 to 3 points.

How do you run Olala Mini on your own machine?

Here is the catch. Upstream Ollama, LM Studio, llama.cpp, vLLM and mlx-lm cannot load Olala 1.0 mini yet, because none of them supports the hybrid Mamba-3 architecture. Every local option below uses one of OVHcloud's forks, so start with the hosted API and move to local inference once you know the model is worth it.

Option 1: the hosted API, no install

OVHcloud AI Endpoints serve Olala through an OpenAI compatible API hosted in Europe. The base URL is https://oai.endpoints.kepler.ai.cloud.ovh.net/v1 and the model name is Olala-v1.0-mini-7A1B. You need an AI Endpoints key for more than a few requests per minute. The same service is reachable through Hugging Face Inference Providers with the ovhcloud provider. The code is the standard OpenAI client:

from openai import OpenAI

client = OpenAI(
    base_url="https://oai.endpoints.kepler.ai.cloud.ovh.net/v1",
    api_key="YOUR_OVH_AI_ENDPOINTS_KEY",
)

response = client.chat.completions.create(
    model="Olala-v1.0-mini-7A1B",
    messages=[{"role": "user", "content": "Summarise this contract clause in plain English."}],
    temperature=0.8,
)
print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Sampling defaults are temperature 0.8, top_p 0.9 and top_k 40, and all published scores use them. Reasoning effort defaults to medium: high for maths, disabled for a direct answer.

Option 2: GGUF on a laptop

For a laptop, the GGUF builds are the practical route: BF16 at 13.6 GB, q8_0-safe2 at 6.9 GB, q6_k at 6.3 GB and q5_k_m at 6.0 GB, all in the OVHaiLLM/Olala-v1.0-mini-7A1B-GGUF repository. The 6-bit file is fastest on Apple Silicon, and the 5-bit file is the smallest with no measured quality loss. You need OVHcloud's llama.cpp fork, linked from the GGUF model card, because upstream llama.cpp does not understand the architecture yet.

Option 3: vLLM on a GPU server

For a server with 24 GB or more of GPU memory, OVHcloud publishes a vLLM fork and a pre-built Docker image, ovhaillm/olala-vllm. The Docker route skips the install; the first start compiles GPU kernels in about 8 minutes:

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
Enter fullscreen mode Exit fullscreen mode

Do not skip the --mamba-ssm-cache-dtype float32 flag. vLLM's default keeps the Mamba recurrent state in bf16, and long generations then degrade into repetition loops. Once the server is up, any OpenAI client can talk to it on http://localhost:8000/v1.

Option 4: Transformers for research

For research code, plain PyTorch plus Transformers works, with trust_remote_code=True:

pip install torch "transformers==5.8.*" accelerate einops
Enter fullscreen mode Exit fullscreen mode
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")
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)
Enter fullscreen mode Exit fullscreen mode

Keep use_cache=True, because the config turns it off. Without the optional kernels this runs correctly but slowly, about 6 tokens per second on a 64-core CPU server. The OVHai-LLM/olala-v1 repository pins a working kernel set if you need speed.

When should you pick Olala over Qwen or Mistral?

Pick Olala when deployment constraints matter more than raw scores: a European team that wants data to stay in Europe, a laptop agent that needs tool calling and multi-turn reasoning on 8 GB of memory, or multilingual European chat. Apache 2.0 allows commercial use, and OVHcloud published the training data recipe and tools, which is rare even among models called open.

Skip it for heavy maths or graduate science, where Qwen3.5 4B is measurably stronger, when you need more than 32K tokens today, or when you need Ollama or LM Studio support right now. Upstream support will probably arrive, but there is no published date, and the 128K version is listed only as coming soon. Avoid the SFT checkpoint as an assistant: OVHcloud warns it is pre-alignment and can be toxic.

What is still unknown?

Three things are still open. First, no independent lab has reproduced the benchmarks, so the 68.0 average and the speed claims are OVHcloud's case for the model until outside testing weighs in. Second, the timeline for upstream support is unknown, so local use means living on forks for now. Third, hosted pricing beyond the free tier is not stated on the model card. Test it on your own workload before committing to it.

Our verdict is simple. Olala Mini 7A1B is not the strongest small model on the benchmarks, and it does not pretend to be. It is the most openly built European model we have seen at this size, it runs on hardware most developers already own, and it is genuinely good at the instruction following and tool calling small agents need. Try it through the hosted API first, measure it on your own prompts, then decide whether the laptop build earns a place in your stack.


Originally published on LogicStack. Run the code examples right in your browser with our free interactive Python and SQL playgrounds — no setup, no sign-up.

Top comments (0)