Domyn-Small

Domyn Small is a 10B-parameter open-weight reasoning model designed for resource-constrained, agentic, and fine-tunable deployments. It pairs a dual-mode (thinking on/off) inference design with grouped-query attention, a native 32k context window (extensible to 131k via YaRN), and tool calling. On reasoning benchmarks it reaches accuracy comparable to leading 7–10B reasoning peers while spending roughly 2–4× fewer reasoning tokens — placing it on a favourable accuracy/cost Pareto frontier for production inference and downstream fine-tuning.

Fine-tune Domyn Small to your domain to unlock its real power and to retain full ownership and control over the resulting model.

Highlights

• Token-efficient reasoning — ~32% of Qwen3.5-9B's reasoning-token budget and ~35% of OLMo-3-7B-Think's at comparable accuracy on several reasoning tasks (Token Efficiency).
• Dual-mode inference — thinking on for deep multi-step reasoning, thinking off for fast, compact output. Toggleable from the system prompt or the API.
• Tool calling — first-class function calling via `` XML tags, with a chat template that handles tool injection automatically. Strong BFCL V3 single-turn results (75.9 Non-Live / 68.3 Live) at ~280 mean tokens per problem.
• Expandable context — 32,768 tokens natively, extensible to 131,072 (128k) via YaRN at inference time.
• Multilingual — 50+ languages with explicit coverage; optimised for English and the Tier-A European set (Italian, Spanish, French, German).

Model Overview

• Developed by: Domyn S.p.A.
• Version: 1.0
• Released and last updated on: May 2026
• Input / Output: Text-only / Text-only
• Model size: ~10B parameters
• Attention: Grouped-Query Attention (48 query heads, 8 KV heads)
• Tokenizer: 256,000-token SentencePiece BPE vocabulary
• Native context: 32,768 tokens
• Extended context: 131,072 tokens (YaRN, 4× at inference time)
• Language(s): 50+ languages; optimised for English and the Tier-A European set (Italian, Spanish, French, German)
• Base model: Initialised from Italia 10B and continually pre-trained on 503B tokens
• Knowledge cut-off date: September 2024 (based on pre-training dataset cut-off)
• License: MIT

A full architecture and training-recipe specification is available in the Domyn Small technical report.

Quickstart

from openai import OpenAI

client = OpenAI(
    base_url="http:///v1",
    api_key="none",
)

response = client.chat.completions.create(
    model="domyn/Domyn-Small-v1.0",
    messages=[
        {"role": "system", "content": "You are Domyn Small, a helpful assistant."},
        {"role": "user", "content": "What is the capital of Italy?"},
    ],
)
print(response.choices[0].message.content)

Deployment

We recommend vLLM ≥ 0.9.2 for all the snippets below.

vLLM — Basic

vllm serve domyn/Domyn-Small-v1.0 \
    --tensor-parallel-size 1 \
    --dtype bfloat16 \
    --max-model-len 32768 \
    --max-num-seqs 256 \
    --gpu-memory-utilization 0.9

vLLM — With Reasoning Parsing

To have vLLM automatically extract the model's `` blocks and expose them as a structured reasoning_content field, add a reasoning-parser flag. Which flag to use depends on your vLLM version.

**vLLM …` format as OLMo 3, and earlier vLLM releases work with the OLMo 3 parser directly:

vllm serve domyn/Domyn-Small-v1.0 \
    --tensor-parallel-size 1 \
    --dtype bfloat16 \
    --max-model-len 32768 \
    --max-num-seqs 256 \
    --gpu-memory-utilization 0.9 \
    --reasoning-parser olmo3

vLLM ≥ 0.21.0 (recommended) — use the Domyn-specific parser plugin shipped with this checkpoint (reasoning_parser_plugin.py). It reads the per-request enable_thinking flag (or the thinking on / thinking off system-prompt directive) and routes streamed output to the correct lane (reasoning vs content) for both modes.

vllm serve domyn/Domyn-Small-v1.0 \
    --tensor-parallel-size 1 \
    --dtype bfloat16 \
    --max-model-len 32768 \
    --max-num-seqs 256 \
    --gpu-memory-utilization 0.9 \
    --reasoning-parser think_block \
    --reasoning-parser-plugin /path/to/reasoning_parser_plugin.py

Replace /path/to/ with the actual path to the plugin file bundled with the checkpoint. The parser name think_block is the registration string declared inside the plugin and must match exactly.

vLLM — Extended Context with YaRN

YaRN scaling may impact model quality on inputs shorter than 32k. Enable it only when you actually need contexts beyond the native 32,768-token window.

vllm serve domyn/Domyn-Small-v1.0 \
    --tensor-parallel-size 1 \
    --dtype bfloat16 \
    # vLLM < 0.12.0
    --rope-scaling '{"rope_type": "yarn", "factor": 4, "original_max_position_embeddings": 32768}' \
    # vLLM >= 0.12.0
    --hf-overrides '{"rope_parameters": {"rope_type": "yarn", "factor": 4.0, "original_max_position_embeddings": 32768}}' \
    --max-model-len 131072

vLLM — With Tool Calling

Tool calling requires three extra flags and the bundled plugin files (shipped with this model checkpoint):

vllm serve domyn/Domyn-Small-v1.0 \
    --tensor-parallel-size 1 \
    --dtype bfloat16 \
    --max-model-len 32768 \
    --max-num-seqs 256 \
    --gpu-memory-utilization 0.9 \
    --enable-auto-tool-choice \
    --tool-call-parser xml_tool_call \
    --tool-parser-plugin /path/to/tool_parser_plugin.py \
    --chat-template /path/to/chat_template.jinja

Replace /path/to/ with the actual paths to the files bundled with the checkpoint.

Transformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "domyn/Domyn-Small-v1.0"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id, dtype=torch.bfloat16, device_map="auto"
)

messages = [
    {
        "role": "system",
        "content": "