Kolibri 1: Aleph Alpha's open-weight AI model

By Synthex

If you want to use AI with internal documents, one of the first questions is where those documents will go. Kolibri 1 gives teams another option: download the model and run it on infrastructure they choose.

Aleph Alpha announced the release on October 3, 2026 (opens in new tab). Kolibri 1 is a text model focused on German and English, with downloadable weights under Apache 2.0, a mixture-of-experts architecture, and support for reasoning and tool calling.

The headline numbers are 78 billion total parameters, 3.46 billion active parameters per token, and up to one million tokens of context. Each describes a different part of the model, and they affect what you can do with it and what running it involves.

What you'll learn

• What Kolibri 1 does and what its parameter and context numbers mean.
• What downloading the weights gives you, including the hardware involved.
• How to start a small server test and evaluate it on work you understand.

What Kolibri 1 is designed to do

Kolibri 1 is a large language model, software trained to work with language and generate text. You can integrate it into an assistant, a document-processing application, or a system that uses external tools. Downloading it gives you the model files; you'll still need software to run them and an interface or application to use the results.

Its German and English focus is deliberate. Aleph Alpha describes uses including multi-step reasoning, coding, extracting structured information, and answering questions over an organisation's documents. These are intended uses, so you'll need to check its answers on your own tasks. The official model card (opens in new tab) describes the model and its limitations.

For example, a team working with German supplier documents and English support notes could test whether it can extract delivery dates, identify missing information, and draft a reply in the appropriate language. The original documents give that team a way to check the answer.

Why 78 billion parameters and 3.46 billion active can both be true

Parameters are the learned numerical values that shape a model's behaviour. Kolibri has roughly 78 billion of them, but it uses a selected portion for each token, a small piece of text it processes or generates.

This is called a mixture of experts, or MoE. Parts of the model act as experts, and a routing mechanism selects which ones handle the current token. The experts are mathematical components. Different tokens can activate different selections.

Using fewer parameters at a time reduces the computation needed per token. The full set of weights still needs to be available in memory, though. You need to account for both when choosing hardware. Aleph Alpha's technical report (opens in new tab) describes 78.1 billion total parameters and 3.46 billion active per token.

What the one-million-token context means

A context window is the amount of text available to the model during a request. It includes the instructions, supplied material, conversation history, and space needed for the response. A larger window gives you more room to provide documents without removing as much text.

Kolibri's published maximum is 1,048,576 tokens. Its native trained context is 262,144 tokens, and Aleph Alpha recommends staying at or below that length for serving efficiency and complex tasks. The developer has validated the larger window, but the recommendation is useful when planning a deployment. These conditions appear in the model card's intended-use section (opens in new tab).

More room doesn't guarantee that a model will find every relevant detail or reconcile every contradiction. Start with a shorter document where you know the answer, then increase the amount of text and check whether the quality holds up.

A large text window also doesn't automatically make a PDF readable. Your application needs to extract its text first, or use a document-processing component that does this.

What open weights let you control

Open weights means the trained model files are available to download. You can choose where to run the model and build an application around it.

Apache 2.0 allows use, modification, and redistribution under its conditions, including commercial use. If you distribute covered files or modifications, keep the required licence and attribution notices and identify changes as required. The Apache licence (opens in new tab) sets out those conditions.

Aleph Alpha specifies that this release's licence covers the published weights and configuration files. It doesn't extend to every part of the training pipeline. The inference plugin is a separate repository with its own Apache 2.0 licence. Calling Kolibri an open-weight model makes the scope clearer. See the model licence terms (opens in new tab) and inference repository (opens in new tab).

The technical report says teams in Germany developed the model and used training infrastructure in Germany and Finland. Where your prompts, logs, and connected tools send data depends on the system you deploy. European development and self-hosting can support your requirements, but you'll still need to assess the complete application for compliance.

Useful applications to consider

An internal document assistant is a sensible place to start. With retrieval-augmented generation, often shortened to RAG, your application finds relevant passages and includes them with the question. For example, it could retrieve a maintenance instruction before asking the model to explain the procedure. Kolibri is designed for this kind of workflow; your application still needs document search and a way to show the evidence.

Another application is structured extraction: taking a paragraph and returning specific fields, such as a supplier name, order number, and delivery date. Decide what should happen when a field is missing. A system that reliably leaves it blank can be more useful than one that fills every box with a plausible guess.

Tool calling lets a model request an operation from your software, such as looking up an order. The software provides the available functions, validates the request, executes an allowed action, and returns the result. Enabling tool calling alone doesn't connect the model to your email, database, or files.

For a first integration, use a lookup tool that only reads information. Inspect the requested arguments and result before adding actions that change records or send messages.

How to read the benchmark results

Aleph Alpha publishes comparisons with other open models. Its product page (opens in new tab) reports 84.3% on the English GPQA Diamond reasoning benchmark, compared with 83.4% for Qwen3.6 35B-A3B. On BFCL v4 overall, which evaluates function calling, Kolibri scores 61.4%, while that Qwen model scores 67.2%.

Those rankings change with the task. They are developer-reported evaluations, with conditions described in the technical report. They don't establish how well the model will handle your documents, tools, or preferred writing style.

I'd use them to choose a candidate, then run a small comparison on work where I can recognise a good answer.

The hardware you need

The FP8 release uses a lower-precision representation for much of the model to reduce its memory footprint. Aleph Alpha lists approximately 78 GB for the model weights, with additional memory needed to run requests. A GPU is a processor that runs many model calculations in parallel; its available memory helps determine how much it can hold.

Its published minimum configurations (opens in new tab) include two A100 80 GB GPUs, two H100 SXM5 GPUs, or a single H200, B200, or B300. These are data-centre GPUs. A typical laptop or a single 24 GB consumer GPU doesn't meet that published route.

Longer prompts and more simultaneous requests increase the resources you need. The minimum hardware list doesn't promise that every listed configuration can serve a million-token request at an acceptable speed.

If you don't have suitable equipment, consider a rented GPU server or discuss deployment options with Aleph Alpha. Check the running and storage costs before downloading the model. The weights being available without a licence fee doesn't make the infrastructure free.

How to start a small server test

This route is for a Linux GPU machine that already meets the requirements, with working NVIDIA drivers, Python 3.12 and its venv module, internet access, and enough disk space for roughly 79 GB of model files plus dependencies. It is a developer setup.

Use a terminal on that machine. If you've rented a server, run the commands there. The vLLM 0.29 installation guide (opens in new tab) documents Linux and Python requirements and recommends a fresh environment.

1. Install the model's serving software

vLLM is software that loads a language model and serves responses through an API, an interface other software can call. Aleph Alpha's inference plugin adds support for loading Kolibri and interpreting its responses.

Create an isolated Python environment and install the plugin release available at launch:

python3.12 -m venv kolibri-env
source kolibri-env/bin/activate
python -m pip install --upgrade pip
python -m pip install "aleph-alpha-inference==1.0.0"

The plugin installs its supported vLLM version, currently the 0.29 series. Use the fresh environment to avoid conflicts with a different version. The plugin repository (opens in new tab) documents installation and serving.

2. Start the server

On a suitable single GPU, start with a short context window:

vllm serve Aleph-Alpha/Kolibri-1 \
  --host 127.0.0.1 \
  --max-model-len 8192 \
  --kv-cache-dtype fp8 \
  --reasoning-parser kolibri1 \
  --tool-call-parser kolibri1 \
  --enable-auto-tool-choice

This adapts the official serving command for a small first test. The 8,192-token limit reduces the memory required for context, while 127.0.0.1 keeps the endpoint accessible from the same machine. The cache setting reduces memory used for temporary processing data; the parsers separate reasoning and tool requests in the responses.

For a two-GPU configuration on one machine, add --tensor-parallel-size 2 to distribute the model across both GPUs, as described in vLLM's multi-GPU serving documentation (opens in new tab).

The first launch downloads the weights and loads the model. Keep this terminal open and wait for the server to finish starting before sending a request.

3. Send a simple request

Open a second terminal on the same machine and run:

curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Aleph-Alpha/Kolibri-1",
    "messages": [
      {"role": "user", "content": "Explain what a mixture-of-experts model is in three sentences for a beginner."}
    ],
    "max_tokens": 256,
    "chat_template_kwargs": {"enable_thinking": false}
  }'

Expect a JSON response containing an answer under choices[0].message.content. This disables thinking for a short connection test. For more demanding work, the model supports reasoning_effort values low, medium, and high through its chat-template settings. Compare answer quality and response time on your task before choosing a default.

If the connection is refused, check that the server is ready and you're querying from the same machine. If startup reports insufficient GPU memory, check the hardware, other GPU workloads, and whether a multi-GPU machine needs the parallelism flag. If the architecture or parser isn't recognised, check that you activated the environment with the plugin installed.

Stop the server with Ctrl+C in its terminal when you've finished. If the machine is rented, stop the billable instance through the provider's controls too.

4. Increase context only when your task needs it

Once the short test works, you can restart the server with a larger --max-model-len. For the maximum documented window, replace --max-model-len 8192 with --max-model-len 1048576 and add:

--hf-overrides '{"max_position_embeddings": 1048576}'

Add that argument to the same serving command; it isn't a command to run on its own. The model card's getting-started instructions (opens in new tab) document the override. Allow for the extra memory and response time, and keep the 262,144-token recommendation in mind for complex tasks.

Give it a task you can check

Start with a document you understand and questions whose answers you can verify. Include a question the document cannot answer. Ask for supporting passages, then check that the quoted text exists and supports the response.

For German and English work, test both languages with your own terminology. For tool workflows, inspect the requested function and arguments. Record response time and resource use alongside correctness, because a deployment has to work at the speed and cost you can support.

If the model handles that small task well, expand to a representative set of documents and compare it with your current approach. You'll have evidence from your own work to base a deployment decision on.