Instructions to use UTF-ai/Beek with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use UTF-ai/Beek with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="UTF-ai/Beek")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("UTF-ai/Beek")
model = AutoModelForMultimodalLM.from_pretrained("UTF-ai/Beek", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use UTF-ai/Beek with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "UTF-ai/Beek"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "UTF-ai/Beek",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/UTF-ai/Beek

SGLang

How to use UTF-ai/Beek with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "UTF-ai/Beek" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "UTF-ai/Beek",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "UTF-ai/Beek" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "UTF-ai/Beek",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use UTF-ai/Beek with Docker Model Runner:
```
docker model run hf.co/UTF-ai/Beek
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

Beek

A 27-billion-parameter language model by UTF.ai, a Dutch company, built on Qwen 3.8 27B and aligned with Dutch public values.

Beek is made for Dutch public organisations: municipalities, provinces, ministries, water boards and the agencies that carry out public tasks. It is made to answer by what Dutch law and the duties of public bodies require.

Ik ben Beek, een taalmodel van UTF.ai, afgestemd op Nederlandse publieke waarden.

Beek, asked "Wie ben jij?"

Highlights

Aligned with Dutch public values, in a definition anyone can check (below).
Dutch first, and English, with the other languages of its base architecture.
Three formats: full precision (BF16), 8-bit (FP8) and 4-bit (INT4), each a branch of this repository (see Formats).
One GPU. The 4-bit version is 20 GB and runs on one 48 GB card, such as an NVIDIA A40.
Tools and agents. The chat template keeps Qwen 3.8's tool-calling format, so Beek can call tools and work as an agent.
Ready for speculative decoding. The weights include a multi-token-prediction head that a server can use to draft tokens ahead.
Long context: 262,144 tokens.
Thinking when it helps. Beek reasons before it answers unless a request switches this off, and a request can set how much it reasons.
Open licence: Apache 2.0.

What "aligned with Dutch public values" means

Dutch public values are what Dutch law and the duties of public bodies require, in five groups: rights and equal treatment, good administration, democratic neutrality, Dutch law on contested questions, and truthfulness. On international questions Beek goes by law, treaties and court rulings, and it reports what any government says, the Dutch cabinet included, as that government's position. No claim is made about the opinions or the culture of the Dutch.

So Beek is made to help where the law allows and decline where the law forbids, to attribute positions to whoever holds them, and to keep out of party politics.

Results

UTF.ai measures Beek with its benchmark, the first exam of Dutch public values (edition 2026.1), beside the open models measured in the same way: every model as it is delivered, here the INT4 weights published in this repository, with thinking off. A model scores on a pair of cases only when it gets both sides right, what a public body may do and what it may not, so guessing scores about 24 out of 100.

Beek scores 37.4: alone in the top tier, and 11 points above Qwen 3.8, the model it is built on. Its lead over each of the other 21 models in the ranking holds after correction for multiple comparisons.

Values and capability

Across: how capable each model is, by the Artificial Analysis Intelligence Index (version 4.3.2). Up: its score on Dutch public values. Bubble size: the GPUs it needs at 16-bit precision. Beek is placed at the index of Qwen 3.8, the model it is built on, because Artificial Analysis does not list it. Mistral Medium 3.5 stands beside the ranking: it was measured in a community 4-bit build.

The full results, with every model's scores, are in UTF.ai's white paper "Who Does Your AI Serve?" (second edition, November 2026), at utf.ai/research.

Model details


Developer	UTF.ai, the Netherlands
Model type	Language model, with the vision encoder of its base architecture. Beek is measured on text; its image and video input are not evaluated.
Architecture	The Qwen 3.8 architecture: 64 layers (48 linear-attention and 16 full-attention layers), 5,120 hidden size, a multi-token-prediction head
Parameters	27 billion
Context window	262,144 tokens
Vocabulary	248,320 tokens
Languages	Dutch and English first, and the other languages of the base architecture

Formats

The model is the same in every format; only the number format of the weights differs.

Format	Branch	Size	Runs on	Notes
INT4: W4A16 (AWQ + GPTQ)	`int4`	20.2 GB	one 48 GB GPU or larger, NVIDIA Ampere and newer	The format UTF.ai serves, and the one Beek's results are measured on. 4-bit integer weights in groups of 64, quantised with AWQ and then GPTQ, and 16-bit activations; the multi-token-prediction head kept in full precision.
FP8: W8A8 dynamic	`fp8`	31.5 GB	one 48 GB GPU or larger	8-bit floating-point weights per channel, and activations per token scaled on the fly. Scores within a point of INT4. Native on NVIDIA Hopper, Ada and Blackwell; on Ampere (A100, A40) vLLM serves it through a weight-only path.
Full precision (BF16)	`main`	55.6 GB	one 80 GB GPU	The weights the other two formats are made from.

Each format is a branch of this repository: choose it under Files and versions (the branch menu shows main), or download it with hf download UTF-ai/Beek --revision int4 (or fp8; leave --revision out for full precision).

Quickstart

Serve with vLLM

Tested with vLLM 0.31.

vllm serve UTF-ai/Beek --revision int4 --reasoning-parser qwen3 --max-model-len 32768

--max-model-len 32768 keeps the memory small; the model takes up to 262,144 tokens where the GPU has room. Use --revision fp8 for FP8, or leave --revision out for full precision.

Ask it

The server speaks the OpenAI chat API.

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="none")
prompt = ("Herschrijf in begrijpelijke taal: 'Indien u zich niet kunt verenigen met dit besluit, "
          "kunt u binnen zes weken na de dag van bekendmaking bezwaar maken.'")
reply = client.chat.completions.create(
    model="UTF-ai/Beek",
    messages=[{"role": "user", "content": prompt}],
    temperature=0,
    extra_body={"chat_template_kwargs": {"enable_thinking": False}},
)
print(reply.choices[0].message.content)

Beek's answer:

Als u het niet eens bent met dit besluit, kunt u binnen zes weken na de dag waarop het besluit bekend is gemaakt, bezwaar maken.

Thinking mode

Beek reasons before it answers unless a request switches this off with "chat_template_kwargs": {"enable_thinking": false}. With thinking off it answers at once, which suits chat, drafting and summaries. With thinking on it works through harder questions first, and "reasoning_effort" in the same chat_template_kwargs sets how much: xhigh (the default), medium or low. The reasoning is returned apart from the answer when the server uses the qwen3 reasoning parser.

Sampling

The defaults shipped in generation_config.json: temperature 1.0, top_p 0.95, top_k 20. For answers that must not vary, such as rewriting, classification or extraction, use temperature 0.

Intended use

An assistant for public servants, who check its answers and stay responsible for every decision.
Drafting, rewriting and summarising documents.
Answering from public documents and an organisation's own sources.
Questions on law, public policy and international affairs.
Coding: writing, explaining and reviewing code.
Agentic work: tasks in several steps in which Beek calls tools.

Limitations

A determined prompt can still move the model, as with any model.
It shares the capabilities, knowledge cut-off and failure modes of its base architecture.
It is not a safety filter, a fact-checker, or a substitute for human review in consequential decisions.

Provenance and attribution

Built on Qwen 3.8 27B by Alibaba Cloud (the Qwen team). The architecture, tokenizer and context window are unchanged; the alignment is in the weights. The fingerprint of the base checkpoint is recorded in utf_alignment/provenance.json.

Licence

Released under Apache 2.0, the licence of Qwen 3.8 27B. The licence text is in LICENSE and the modification is stated in NOTICE; all original copyright and origin notices are kept.

Versions

This repository holds one version of Beek, from November 2026. Each branch is that version in one format (main full precision, fp8, int4). A new version replaces it on every branch, and a commit id stays downloadable only while its version is the current one.

Citation

@misc{utfai2026beek,
  title        = {Beek: a language model aligned with Dutch public values},
  author       = {{UTF.ai}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/UTF-ai/Beek}}
}

About UTF.ai

UTF.ai is a Dutch company that makes language models and AI applications for public organisations in the Netherlands. Contact: info@utf.ai

Downloads last month: 98

Safetensors

Model size

28B params

Tensor type

BF16

Model tree for UTF-ai/Beek

Base model

Qwen/Qwen3.8-27B

Finetuned

(886)

this model

Quantizations

2 models