domyn/Domyn-Edge-SFT

Domyn Edge SFT

Phased release. Domyn Edge is a rolling release in three bundles. This checkpoint was released on October 20, 2026, as part of the first bundle, together with the pre-trained domyn/Domyn-Edge-Base. Further post-training checkpoints follow, up to the fully post-trained model in the final bundle. See Open resources for everything released so far.

This repository holds the supervised fine-tuning checkpoint: Domyn Edge Base after one broad pass over math, code, tool calling and instruction following. It chats, reasons and calls tools, and gives others a clean starting point for their own fine-tuning.

It has had no reinforcement learning and no preference optimization. It is stage 1 of our post-training protocol, not its output. Expect weaker single-attempt robustness than a fully post-trained model of the same size, and read Limitations before deploying it.

Table of contents

1. Model summary
2. How to use
3. Evaluation
4. Post-training
5. Limitations
6. License
7. Citation

Model summary

Domyn Edge SFT is the supervised fine-tuned version of Domyn Edge Base, a 4B-parameter dense transformer pre-trained from scratch on 13 trillion tokens, end to end on European public infrastructure. The supervised pass targets agentic work at long context: multi-turn tool calling, agentic coding, and question answering over very long documents.

Key features

• Reasoning: the model reasons in a <think> block before answering. Thinking is on by default and can be turned off per request.
• Agentic: trained on multi-turn tool-calling trajectories against about 200 real tools and on agentic coding trajectories from real software repositories.
• Long context: the SFT mix includes conversations of up to 512k tokens; 256k is the recommended working context.
• Fully open: the weights and the recipes that reproduce this checkpoint are released now, and the post-training mix follows in the second bundle, so the model can be audited, reproduced and continued rather than only run.
• Multilingual: strongest in five European languages (English, Italian, Spanish, French, German), with eight further languages at lower coverage; see Limitations.

The architecture is unchanged from the base model; see the Domyn Edge Base card for details.

How to use

Recommended environment

Same as the base model. We tested Domyn Edge with these versions installed together. Other versions may work.

# CUDA 12 drivers (525+): cu129 or cu126. Drivers 580+: drop --index-url for the CUDA 13 build.
pip install "torch==2.13.0" --index-url https://download.pytorch.org/whl/cu129
pip install "transformers==5.16.1" "accelerate==1.14.0" "einops==0.8.2"

Transformers

With the recommended environment installed:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "domyn/Domyn-Edge-SFT"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

messages = [
    {"role": "user", "content": "Write a Python function that checks if a string is a palindrome."},
]
inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt",
    return_dict=True,
).to(model.device)

# Sampling settings come from the repo's generation_config.json.
outputs = model.generate(**inputs, max_new_tokens=4096)

# Drop the reasoning: keep only what follows </think>.
new_tokens = outputs[0][inputs["input_ids"].shape[-1]:].tolist()
end_think = tokenizer.convert_tokens_to_ids("</think>")
start = new_tokens.index(end_think) + 1 if end_think in new_tokens else 0
print(tokenizer.decode(new_tokens[start:], skip_special_tokens=True).strip())

Thinking. The chat template opens every assistant turn with <think>, so the generated text starts directly with the reasoning and only the closing </think> appears in it. Reasoning often runs to thousands of tokens, so leave room in max_new_tokens. To skip it, pass enable_thinking=False to apply_chat_template.

Tool calling

Tools are passed as JSON schemas through tools=:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "domyn/Domyn-Edge-SFT"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "What is the weather in Milan?"}]
inputs = tokenizer.apply_chat_template(
    messages,
    tools=tools,
    add_generation_prompt=True,
    return_tensors="pt",
    return_dict=True,
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=4096)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=False))

The model writes each call as XML after its reasoning (line breaks omitted here): <tool_call><function=get_weather><parameter=city>Milan</parameter></function></tool_call>. To continue the conversation, append the assistant turn and the result as a message with role tool, then generate again.

vLLM

Stock vLLM does not yet support Domyn Edge. Released vLLM versions stop at startup, even with --trust-remote-code, with Model architectures ['DomynEdgeForCausalLM'] are not supported.

Native support is pending in vllm-project/vllm#62544. Until it is merged and released, install vLLM from the PR branch. The branch follows vLLM main, which requires PyTorch 2.14 built for CUDA 13, so it needs NVIDIA driver 580 or newer:

git clone https://github.com/vllm-project/vllm.git
cd vllm
git fetch origin pull/62544/head:domyn-edge
git checkout domyn-edge
VLLM_USE_PRECOMPILED=1 uv pip install --editable . --torch-backend=auto

VLLM_USE_PRECOMPILED=1 downloads prebuilt CUDA 13 kernels instead of compiling vLLM from source. The install replaces the PyTorch build from the recommended environment with PyTorch 2.14 for CUDA 13. On older drivers, use Transformers until a vLLM release with Domyn Edge support is available for CUDA 12.

Then serve the model with its reasoning and tool-call parsers:

vllm serve domyn/Domyn-Edge-SFT \
  --trust-remote-code \
  --max-model-len 262144 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder

Query it with any OpenAI-compatible client:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

response = client.chat.completions.create(
    model="domyn/Domyn-Edge-SFT",
    messages=[
        {"role": "user", "content": "Write a Python function that checks if a string is a palindrome."},
    ],
    max_tokens=4096,
)
print(response.choices[0].message.content)

The reasoning parser returns the reasoning separately from content. To turn thinking off, add extra_body={"chat_template_kwargs": {"enable_thinking": False}} to the request. To serve longer contexts, raise the limit at load time as shown on the base model card.

Evaluation

We compare this preliminary SFT checkpoint against the final post-trained releases of Qwen3.5 4B and SmolLM3 3B, which already include the full RL phase. Our own fully post-trained model comes later in the release sequence.

Bold marks the best score in each row; underline marks the best fully open model. SmolLM3 3B is the only other fully open model in the set, so it sits next to Domyn Edge SFT.

Group	Benchmark	Metric	Domyn Edge SFT	SmolLM3 3B	Qwen3.5 4B
Math	AIME 2026	pass@16	96.7	60.0	93.3
	AIME 2025	pass@16	93.3	63.3	90.0
	GSM8K	accuracy	94.6	80.9	95.0
	MGSM (en, es, fr, de, ru)	accuracy	85.8	80.4	89.8
Knowledge and reasoning	GPQA Diamond	accuracy	56.3	37.8	78.2
	MMLU-Pro	accuracy	63.5	54.4	79.4
Instruction following	IFEval	prompt strict pass@4	90.2	79.9	92.6
	IFBench	prompt strict pass@4	34.7	25.3	65.0
	IFStruct	pass rate	51.7	38.0	70.2
Function calling	BFCL v4 (overall)	accuracy	36.5	18.4	43.2
	BFCL v4 (non-live)	accuracy	51.9	75.0	75.8
	BFCL v4 (live)	accuracy	75.9	62.2	76.5
	BFCL v4 (multi-turn)	accuracy	35.9	0.9	45.4
	BFCL v4 (memory)	accuracy	27.3	11.4	31.0
Agentic	τ²-bench Airline	accuracy	54.0	32.0	66.0
	τ²-bench Retail	accuracy	47.4	6.1	54.4
	τ²-bench Telecom	accuracy	45.6	12.4	86.0
	τ³-bench Banking	accuracy	3.1	1.0	8.3
	SWE-bench Verified	mean	33.6	0.2	40.0
Code	SciCode (main problems)	pass@4	6.2	0.0	10.8
	SciCode (subproblems)	pass@4	26.5	8.6	32.7
	BigCodeBench	pass@4	55.9	50.4	59.7
	MBPP	pass@4	96.6	88.6	92.8
	LiveBench Coding	pass@4	79.7	32.8	88.3
Long context	RULER 4k	accuracy	93.7	90.4	94.7
	RULER 8k	accuracy	91.8	84.6	94.3
	RULER 16k	accuracy	88.3	80.3	94.0
	RULER 32k	accuracy	85.7	74.5	94.0
	RULER 64k	accuracy	83.0	n/a*	93.5
	RULER 128k	accuracy	78.0	n/a*	93.2
	RULER 256k	accuracy	73.8	n/a*	93.7

* SmolLM3 3B has a 64k-token context window, so a 64k RULER prompt plus its answer does not fit; it is evaluated up to 32k only.

Post-training

Protocol

Our post-training follows MOPD (Multi-Teacher On-Policy Distillation). Domyn Edge SFT is its first stage:

Stage	What it does	Output
1. Broad SFT	One supervised pass over math, code, tool calling and instruction following	This checkpoint
2. Domain teachers	One teacher per capability, each a specialized SFT plus GRPO, all starting from this checkpoint	Teacher models, bundle 2
3. Distillation	The student, also initialized from this checkpoint, generates rollouts; the teachers score them token by token and a reward model scores the final output	The post-trained model, bundle 3

Data

The recipes that reproduce this checkpoint are released alongside the weights in Domyn Forge. The post-training mix, with a dataset card giving the full statistics, follows in the second bundle.

The 64k mix holds 26.17M conversations and 228.06B tokens, packed into 65,536-token sequences. Only assistant-turn tokens contribute to the loss. The largest sources by conversation count are INTELLECT-3-SFT (23.2%), Nemotron-SFT-Math-v3 (13.9%), Nemotron-SFT-Competitive-Programming-v2 (11.2%), Nemotron-SFT-Multilingual-v1 (10.4%), Dolci-Think-SFT-7B (7.8%), Nemotron-SFT-Science-v2 (6.4%), Nemotron-Finance-v1 (4.2%) and ARC-AGI-v1 (3.1%), followed by a long tail of math, multilingual, reasoning, agentic, software engineering, research and instruction-following datasets.

Long-context data is scarce in public SFT corpora: in the 64k mix, only 7.1% of tokens sit in conversations longer than 64k, and 87% of those come from a single dataset. We generated two datasets to fill the gaps in long-context and agentic data:

• Long-context QA: 115,727 conversations and 21.37B tokens at 128k to 512k context, seeded from the Dolma 3 longmino pool. The first user message holds a full document, and several question-and-answer turns follow. One part asks questions that combine facts from distant sections; the other makes every answer checkable by code, as a span of the context or a value computed from it.
• Tool-calling trajectories: multi-turn conversations against a live agent platform serving about 200 tools, native and MCP, plus three simulated stateful servers (a fictional company's mailbox, calendar and chat). A simulated user varies persona, language and how gradually the goal is revealed, and in some rollouts the agent must discover tools through search. An LLM judge scored groundedness and tool correctness; 12,647 of 25,543 rollouts were kept.

Languages. English is 86.6% of messages. The multilingual data spans 12 further languages: Russian, Chinese, German, French, Japanese, Spanish, Italian, Portuguese, Arabic, Dutch, Indonesian and Turkish.

Stages

The checkpoint was built in three supervised stages. Each starts from the previous stage's weights with a fresh optimizer and schedule and trains for one epoch. The two extension stages train on a "cascade" mix: all available data above the previous context length, joined with a downsampled copy of the shorter mix so short-context skills are preserved.

Stage	Sequence length	Mix tokens	Steps	Tokens per step	Peak LR
64k base	65,536	228.1B	14,195	17.0M	1e-4
128k cascade	131,072	29.8B	2,022	16.8M	1e-5
512k cascade	524,288	57.3B	3,592	16.8M	1.5e-5

Each stage shifts the mix toward long context, at the expense of math and code:

Task	64k base	128k cascade	512k cascade
Long context	1.2%	14.9%	43.0%
Math	31.7%	24.2%	14.4%
Code	20.8%	15.9%	7.4%
Multilingual	12.2%	9.4%	5.6%
STEM	10.9%	8.3%	4.4%
Software engineering	3.6%	7.6%	8.3%
Agentic	3.9%	7.9%	7.6%
Reasoning	4.2%	3.3%	4.0%
Instruction following	4.4%	3.3%	2.1%
Finance	4.2%	3.2%	2.0%
Deep research	1.3%	1.0%	0.6%
Other (mixed, chat, safety)	1.4%	1.0%	0.6%

All three stages ran on about 256 custom NVIDIA A100 64GB GPUs on Leonardo at CINECA, with Domyn Forge.

Open resources

For an overview of the release, see the launch blog post.

Released in bundle 1 (this release):

• SFT model: domyn/Domyn-Edge-SFT
• Base model: domyn/Domyn-Edge-Base
• Intermediate checkpoints: domyn/Domyn-Edge-Base-checkpoints
• Stage 1 pre-training dataset: the 8.44T mix, with per-source provenance, filtering and token counts
• Domyn Forge: the training code, pre-training and fine-tuning recipes
• SDAG: the DAG execution engine with SLURM integration that ran the data pipeline
• Domyn Swarm: a toolkit to spin up vLLM endpoints and run high-throughput inference jobs on SLURM and DGX Cloud Lepton
• Collection: Domyn Edge on Hugging Face

Coming in later bundles: the remaining per-stage pre-training datasets, the post-training mix of this checkpoint, the teacher models and their post-training data (bundle 2), and the fully post-trained model (bundle 3). The technical report is expected in November 2026.

Limitations

No reinforcement learning, no preference optimization. This checkpoint comes before the rest of the post-training protocol. It is measurably weaker than a fully post-trained model of the same size on knowledge, on instruction following under strict constraints, and on the agentic suites. Where the evaluation reports pass@4 or pass@16, single-attempt behavior will be noticeably worse.

Safety work is incomplete. The supervised pass targets capability, not alignment: safety data is 0.10% of the 64k mix and 0.04% of the 512k mix. The model has had no dedicated safety tuning or red teaming, and its refusal behavior is only what the supervised data happened to teach. Do not deploy it in a user-facing application without your own safety layer and evaluation.

Factual accuracy. Like other models of its size, Domyn Edge SFT can produce plausible but incorrect statements, especially on knowledge-intensive questions. We recommend pairing it with retrieval or tool use.

Recommended context is 256k, not 1M. The base model was trained to a 1M-token context, but RULER scores degrade past 256k and the long-context supervised data stops at 512k. Treat 256k as the supported working context and anything beyond it as experimental.

Prompt injection on code and tool inputs. The model is susceptible to instructions embedded in code passed to it as input, and the same weakness applies to tool results, which it is trained to read and act on. Do not place untrusted content in the context of an application that acts on the model's output.

Uneven multilingual coverage. Given the post-training mix, expect lower performance on the remaining eight languages (Portuguese, Russian, Chinese, Japanese, Arabic, Dutch, Indonesian, Turkish) than on English and the four primary European languages (Italian, Spanish, French, German).

License

This model is released under Apache 2.0.

Citation

If you find this work valuable, please consider citing it:

@misc{domynedge2026,
  title  = {Domyn Edge},
  author = {Domyn},
  year   = {2026},
  note   = {Technical report, forthcoming in November 2026.},
}