Open-weight model adaptation
Fine-tune open models on your own data, on your own hardware
- Training data never leaves your environment
- You own the resulting weights
- Licence terms checked before training
Labelled instances per class
- person4,200
- hard hat3,100
- hi-vis vest2,700
- forklift380
forklift: under 1,000 examples, collect more
1/4Images are de-duplicated, balanced and split before anyone labels them. Classes with too few examples are flagged early.
First, the honest question
Fine-tuning is often not what a team actually needs
The two techniques get used interchangeably and they solve different problems. Getting this wrong is the most expensive mistake in a private AI project, because fine-tuning costs real money and has to be repeated as your data changes.
If the goal is for a model to answer from documents that change, you want a private knowledge assistant built on retrieval. Fine-tuning earns its cost when behaviour, format or domain fluency is the gap.
| Topic | Retrieval (RAG) | Fine-tuning |
|---|---|---|
| What it changes | What the model can see at question time | How the model behaves and writes |
| New information | Available as soon as it is indexed | Requires retraining |
| Citations | Every answer can name its source | No inherent provenance |
| Cost profile | Mostly build and storage | GPU time, repeated on each update |
| Best for | Facts, documents, anything that changes | Format, tone, task specialisation, thin domains |
Where adaptation pays
Cases where a general model is genuinely not enough
These are the gaps retrieval cannot close, because the problem is not what the model can see but how it behaves with what it sees.
Languages and scripts with thin coverage
Open models carry broad multilingual coverage, but it is uneven. Where a language, dialect or script is underrepresented, adapting on your own material closes a gap no amount of retrieval will.Domain vocabulary
Clinical shorthand, legal drafting conventions, engineering part nomenclature and internal product names are frequently absent from public training data and constant in your work.Strict output formats
When output has to be valid structured data, or follow a template a downstream system parses, fine-tuning is far more reliable than prompt instructions repeated on every call.Task specialisation
A model doing one narrow job well can be considerably smaller than a general model doing it adequately, which directly lowers the hardware it needs.Smaller models, cheaper inference
Specialising a smaller model is often the cheapest route to a latency target, because inference cost is paid on every request while training is paid once.Behaviour under your rules
Where a model has to consistently refuse, escalate or flag in ways your policy defines, that behaviour can be trained rather than hoped for.
How we do it
The data work is the project
Most of the effort in a fine-tuning project goes into assembling, cleaning and grading the training set. The training run itself is usually the short part, and it is not where projects fail.
We measure the base model on your evaluation set before training anything. Without that baseline there is no way to tell whether a fine-tune improved the model or simply changed it.
- Stage 1
Decide whether to fine-tune at all
We test whether better retrieval or better prompting closes the gap first. If it does, that is the recommendation, and it costs you far less to run.A clear build recommendation - Stage 2
Select a base model and check its licence
Candidates are shortlisted on capability in your domain, the hardware you have, and licence terms for your intended commercial use. Licence review happens before training, not after.Base model with licence cleared - Stage 3
Build and grade the training set
Examples are assembled from your own material, cleaned, deduplicated and checked for consistency, with a held-out split reserved for evaluation. This is where most of the project's time goes.Training and evaluation splits - Stage 4
Baseline the untrained model
The base model is measured on your evaluation set so there is a number to beat, and so you can see whether adaptation was needed at all.Measured baseline - Stage 5
Train on your infrastructure
Training runs on your own GPUs or inside your cloud account, so the training set never leaves your environment. Parameter-efficient methods keep the cost down and make iterating practical.Adapted model weightsParameter-efficient fine-tuningYour GPUs or VPC - Stage 6
Evaluate, quantize, hand over
We check gains on the target task and that general behaviour has not degraded, quantize for your serving hardware, then hand over weights, training pipeline and runbooks so you can retrain yourselves.A model you own and can retrain
What you end up with
Weights, pipeline and the right to run them
A hosted fine-tune leaves you with an endpoint that works while you keep paying. Adapting an open model on your own infrastructure leaves you with artifacts.
- The fine-tuned weights, as files you hold
- The training pipeline, so your team can retrain as data changes
- The evaluation set, so future changes can be measured
- Freedom to deploy on-premises, at the edge or in your own cloud
For vision workloads the same approach applies through our model training service, and managed services can run monitoring and retraining if you would rather not.
Where training and inference run
Both on your infrastructure
Training and serving on your own GPUs, with the training set never leaving the building.Train in cloud, serve on-premises
Burst GPU capacity in your own cloud account for training, with inference kept on local or edge hardware.
Getting started
From data review to a model you can retrain
Step 1: Data review
Feasibility first
We look at the material you have, whether it can form a usable training set, and whether retrieval or prompting would get you there more cheaply.
- NDA on request
- Honest build-or-skip answer
Step 2: Proof of concept
4–6 weeks
Base model baselined, training set built, a first adaptation trained and measured on your own evaluation set.
- Measured against a baseline
- Trained on your infrastructure
Step 3: Production
Serve, monitor, retrain
We quantize for your serving hardware, deploy into your environment and hand over the pipeline so retraining is something your team does.
- You own the weights
- Retraining runbook included
Guides from our engineers
Go deeper on private AI
Choosing a model, sizing the hardware, and what each deployment option actually protects against.
- Which Open-Weight LLM Should You Self-Host?Technical
- What GPUs Do You Need to Self-Host an LLM?Hardware
- RAG or Fine-Tuning? The Wrong Answer Is ExpensiveDeep dive
- What Does It Cost to Run Your Own LLM?Cost
- Air-Gapped, Private Cloud or Sovereign Cloud: Which Do You Need?Architecture
- Deploy an Open-Weight LLM on Your Own Server with vLLMTutorial
- Self-Hosted Coding Assistants: What Works Air-GappedGuide
- Data Residency Rules That Shape AI Projects in 2026Regulation
- On-Premises vs Cloud Computer Vision Deployments – An Enterprise GuideDeep dive
FAQ
Questions about fine-tuning
Fine-tuning changes how a model behaves: the format it answers in, the vocabulary it uses, the task it is specialised for, and how well it handles a domain that is thinly represented in public training data. It does not reliably teach a model new facts, and facts change. If your goal is for the model to know what is in your documents today, retrieval is the cheaper and more maintainable answer, and it can cite its sources. We often build retrieval first and fine-tune afterwards, once it is clear what retrieval alone cannot fix.
Far less than teams expect for style, format and task adaptation, and far more than they expect for broad domain knowledge. Quality and consistency matter more than volume: a few thousand well-constructed, consistent examples usually beat a large, noisy set. The honest first step is a data review, because in most projects preparing the training set is the majority of the work.
Yes. You own the fine-tuned weights, the training pipeline and the artifacts, and you can run them wherever you choose. What you also need to check is the base model's licence, because open-weight models carry different terms on commercial use and redistribution. We check licence terms against your intended use as part of model selection, before any training starts.
Yes, and for most clients that is the point. Training can run on your own GPUs or inside your own cloud account and region, so the training set never moves. Where you have cloud capacity for training but want inference to stay on-premises or at the edge, we split the two, which is a common arrangement.
This is one of the clearest cases for adaptation. Open-weight model families carry broad multilingual coverage, but coverage is uneven, and performance on a specific language, dialect, script or domain vocabulary is an empirical question rather than a claim to accept. We benchmark candidates on your own material first, then adapt where the gap justifies it.
An evaluation set built before training starts, drawn from your real tasks and graded by your own people. We measure the base model on it first, so there is a baseline to beat, and check that gains on the target task have not degraded general behaviour. Without that baseline, a fine-tune is a change rather than an improvement.
Related
Keep exploring
- LLMs & agentsSovereign AIPrivate LLMs and vision models on your own servers, VPC or air-gapped network.
- Computer visionModel trainingData labelling, training, evaluation and retraining for vision models.
- LLMs & agentsPrivate knowledge assistantAn internal assistant that answers from your own documents, with citations, on hardware you control.
- Computer visionManaged AI servicesMonitoring, retraining and support for models in production.
Book a strategy session
Discuss a fine-tuning project
Tell us the task, roughly what training material you hold, and where training and inference need to run. An engineer will reply within one business day, under NDA if you need it.
- Send the form, it takes 2 minutes
- We reply within 1 business day, under NDA if you need it
- A 30-minute call to scope feasibility and next steps