Your data.
Your domain.
Your model.
We fine-tune open-weight models on your company's data — manuals, tickets, contracts, processes, terminology — and prove the gain on a frozen benchmark before anything ships. Trained in the EU. You get the weights.
| arc_easy | 0.71 | 0.78 | +7 |
| boolq | 0.83 | 0.89 | +6 |
| hellaswag | 0.59 | 0.62 | +3 |
| sl→en BLEU | 30.9 | 35.0 | +4.1 |
| ASR WER | 46.8 | 22.3 | −52 % |
General models have never seen your business.
Frontier APIs are excellent at the average case. Your tickets, manuals, contracts and processes are not the average case — and the last 20 % of quality is where the value is.
It has not read your documents
Your product manuals, support history, procedures and terminology exist only inside your company. No off-the-shelf model has seen them — so it guesses, confidently.
Prompts get you to 80 %
Exact output formats, house terminology, tool calls that work every time, answers in your language — the last 20 % is trained in, not prompted in.
Per-token APIs don't scale, or comply
Sending customer data to a foreign API is a compliance and lock-in problem. A small model trained on your data runs on your own servers at a flat cost — and the weights are yours.
| What matters | Public API | Prompting + RAG | Fine-tuned with us |
|---|---|---|---|
| Data stays in the EU, under your control | ✕ | ~ | ✓ |
| Your terminology and output formats, every time | ~ | ~ | ✓ |
| Reliable tool calls into your systems | ~ | ~ | ✓ |
| Facts that change dailyretrieval belongs here — we combine both | ✕ | ✓ | ✓ |
| Flat cost at scale, runs offline | ✕ | ~ | ✓ |
| You own the model | ✕ | ✕ | ✓ |
From raw data to a model you own.
Six capabilities, one pipeline. Take any of them alone or the whole chain end-to-end. Every one has been exercised on a model you can download.
Continued pre-training (CPT)
Teach a base model a whole language or a domain corpus — billions of tokens of cleaned, deduplicated, licence-tracked text.
- Full-parameter training for dense models; high-rank QLoRA for 30B+ mixture-of-experts
- Perplexity gates on held-out text after every checkpoint
- Retention mixes so the model keeps what the base did well
- Packed sequences, crash-resilient multi-day runs
Supervised fine-tuning (SFT)
Shape behaviour: chat, translation, tool calling, reasoning, identity — in the model's own template, the one your serving stack renders.
- Native function calling with multi-turn call → result → answer loops
- Reasoning distillation from a stronger teacher, judge-filtered
- Identity, tone and policy tuning
- Sequential re-tunes that build on earlier adapters
Dataset engineering
Training-ready corpora with provenance — not scraped piles. Half of every program is here.
- One schema, quality scoring, exact + embedding dedup, deterministic splits
- Licence gating: commercial mix and research mix from the same sources
- Teacher distillation with judge filtering; synthetic dialogues from verified blocks
- Domain translation with terminology freezing — codes, names, IDs survive intact
- Exports for CPT, SFT and preference training (DPO/GRPO) + frozen hold-outs
Training runs as a service
Bring data, get back a model. Or bring nothing and we build the data too.
- GPU capacity we control — own and vetted EU partner clouds — or your cloud / air-gapped hardware
- Auto-resume wrappers and checkpoint discipline
- Merged bf16 weights, LoRA adapters and GGUF quantizations delivered together
- Model card with full provenance and the numbers behind every claim
Evaluation flywheel
"Better" is measured, not asserted. The benchmark is defined before the data is touched.
- Frozen, versioned benchmark sets — never edited, only extended
- Objective track (accuracy, BLEU/chrF, WER/CER) + multi-judge track
- Regression-flagging scoreboard across every model version
- Go/no-go on numbers before anything ships
Deployment & speech
From a 4B model on a laptop to a 35B mixture-of-experts on a workstation — with vision, tools and voice.
- GGUF Q4–Q8 for llama.cpp / LM Studio; vLLM and transformers recipes
- Image input and tool use working in production, not just in the demo
- Streaming speech recognition and text-to-speech fine-tuning
- Optional hosting or on-site install that runs unplugged
Five steps, one number at the end.
A first measured model lands within weeks, not quarters. Every phase ends with something you can check.
- Scope
Define the job and the eval
The users, the task, the frozen eval set. An audit of your data and its licences. A written go/no-go criterion.
- Data
Build the corpus
Clean, translate, distil and mix. Retention slices protect what the base already does well.
- Train
CPT → SFT → re-tunes
Each checkpoint gated by a quick eval so bad runs die early and good ones get the budget.
- Evaluate
Base vs tuned vs alternatives
Head-to-head on the frozen benchmark, including the API or RAG setup you were considering.
- Ship
Weights, GGUF, card, recipe
Hand-over workshop. Hosting or an on-site install if you want it. No dependency on us remains.
Everything below is public.
Every model and dataset sits on Hugging Face with a card, its provenance and its numbers. Slovenian is our reference implementation — the same pipeline runs on your domain.
Qwen3.6-35B-A3B · base vs CPT+SFT (Slovenian)
Slovenian-LLM-Eval · acc_norm · n=100/task · 4-bit eval| Task | Base | Tuned | Δ | base ░ tuned ▓ |
|---|---|---|---|---|
| arc_easy | 0.71 | 0.78 | +0.07 | |
| arc_challenge | 0.48 | 0.51 | +0.03 | |
| hellaswag | 0.59 | 0.62 | +0.03 | |
| piqa | 0.65 | 0.64 | −0.01 | |
| openbookqa | 0.48 | 0.51 | +0.03 | |
| winogrande | 0.62 | 0.63 | +0.01 | |
| boolq | 0.83 | 0.89 | +0.06 | |
| average | 0.623 | 0.654 | +0.031 |
Qwen3.6-35B-A3B Slovenian
A 35B mixture-of-experts (3B active) taught Slovenian through continued pre-training, then chat and translation SFT, then a tool-calling re-tune that kept the language gains. Vision and native function calls included.
Sokol 4B — on-device assistant
A dense 4B model pre-trained on 1.78 billion Slovenian tokens, then fine-tuned on ~250k examples of chat, translation, tool calling and teacher-distilled reasoning. One repo, full weights plus Q4–Q8 GGUF. Runs on a laptop.
Vran 27B — biomedical research model
We built the corpus first: 140,063 Slovenian medical instruction records, machine-translated from a provenance-tracked English gold set with a purpose-built medical translation model and a four-layer QC gate, plus a dedicated eval suite. Then we trained the model. Research use.
Slovenian streaming speech recognition
Full fine-tune of NVIDIA's Nemotron 0.6B streaming recogniser on 962 hours of Slovenian speech, scaled up in versions with no catastrophic forgetting. Word-error rate halved on studio speech and cut by two thirds on multi-domain audio. Deployed on CPU as GGUF.
Slovenian text-to-speech voices
LoRA fine-tunes of two open speech generators on Slovenian studio speech, closing the loop of a fully local speech-in → speech-out assistant with camera vision and tool use — served from one command in the browser.
Published datasets
A cleaned continued-pre-training corpus, a 120,000-pair bidirectional EN↔SL translation SFT set, the medical instruction corpus and its evaluation suite — each with a card that states sources, licences and how it was built.
What companies fine-tune with us.
Typical starting points. Most programs combine two or three.
Customer support & service
Assistants trained on your ticket history and manuals: consistent answers, your tone, escalation when unsure.
Documents & extraction
Contracts, invoices, forms, reports: structured extraction, classification and summaries in your schema, in your language.
Internal knowledge
Procedures, standards, ISO documentation, engineering notes — a colleague that has actually read them, offline.
Agents & automation
Reliable tool calling into your ERP, CRM or ticketing API. Trained on your function signatures, tested on pass rate.
Speech & voice
Call transcription with your vocabulary, voice bots and dictation — recognition and synthesis that run on your own servers.
Language adaptation
Slovenian or any under-served language: continued pre-training and instruction tuning so the model is fluent before it is expert.
Your data stays in the EU. The model leaves with you.
We train on GPU capacity we control — our own and vetted partner clouds inside the EU. Either way your data is handled under NDA and never leaves European jurisdiction.
What you receive
- ModelMerged weights + LoRA adapters
- DeploymentGGUF / vLLM build + serving recipe
- DataEvery dataset we built, with provenance
- EvaluationFrozen benchmark + base-vs-tuned scoreboard
- DocumentationModel card, data card, training configs
- Hand-overWorkshop; optional hosting or on-site install
The rules
- Your data is handled under NDA, on infrastructure we control, inside the EU. GDPR is the default, not an add-on.
- Air-gapped training for the most sensitive data: we run with the network cable unplugged and hand over the drive.
- Open-weight bases only — Qwen, Gemma, Llama, Mistral, Nemotron — with the licence of every base and every data source tracked.
- You receive the weights, the adapters, the datasets, the eval set and the provenance record. No dependency on us remains unless you want one.
- Everything is versioned — data, configs, checkpoints, scores — so a result can be reproduced a year later.
Start small, measure, then commit.
Three ways to work with us. Most teams start with the pilot and decide on the numbers.
Pilot
One eval set, one dataset, one fine-tune, one report. The cheapest way to learn what your data can do — and whether it's worth going further.
- Scoping week + data audit
- First tuned model, base-vs-tuned scoreboard
- Written recommendation for the next step
Full program
CPT → SFT → evaluation → deployment for a production model, including the dataset engineering and the serving recipe.
- Corpus build, translation or distillation as needed
- Multi-stage training with checkpoint gates
- GGUF / vLLM delivery, model card, hand-over workshop
Flywheel retainer
New data in, retrain, re-evaluate, ship — every month, with the scoreboard as the contract.
- Versioned benchmark that grows with your use cases
- Regression alerts before users notice
- Base-model upgrades when a better open model appears
GPU time is also available on its own for teams that bring their own pipeline.
Straight answers.
Who owns the model?
You do. Weights, adapters, the datasets we build for you, the eval set and the provenance record are delivered to you. We keep nothing you don't want us to keep.
Fine-tuning or retrieval (RAG)?
Usually both. Retrieval is right for facts that change daily; fine-tuning is right for behaviour — formats, terminology, tool use, tone, and making a small model do what only a large one could. The pilot tests which one actually moves your metric before you commit.
Which base models do you work with?
Any open-weight model whose licence fits your use: Qwen, Gemma, Llama, Mistral for text; Nemotron and Parakeet for speech recognition; open TTS models for speech synthesis. We track the licence of every base and every data source, and we will tell you if a combination is not commercially usable.
Which languages?
Any. Most industry programs run in the customer's language on top of a strong multilingual base; Slovenian is our proven case end to end. For under-served languages the same recipe — continued pre-training, fine-tuning, frozen evaluation — applies, and we assess honestly how much usable text exists before promising anything.
How much data do I need?
For fine-tuning, a few thousand high-quality examples already move the needle. For continued pre-training, hundreds of millions of tokens. What you don't have, we can build, translate or distil — that is half of what we do.
Can the model run offline?
Yes. Our 4B models run on a laptop; 27–35B models on a single workstation GPU. Everything we ship works with the network cable unplugged.
Does this help with the EU AI Act?
With the documentation side, yes: every model ships with a data card, provenance record, training configs and evaluation results — the artefacts transparency and record-keeping obligations ask for. We are not lawyers; we give your compliance team what it needs.
How long does it take?
A measured pilot model within weeks. A full program depends on data readiness; you get a dated schedule after the scoping week, and every phase ends with a number you can check.
Send us fifty examples.
Show us fifty real prompts and answers from your domain. Within a week we'll tell you what a model trained on your data could do — and exactly what it would take.