01Models & intelligence · 04
A model built from the data only you have.
When an off-the-shelf model does not know your domain, your language or your instruments, we build one that does: sized to the task, trained on your corpus, evaluated against your work and handed over with the weights.
For teams whose data is specialised enough that a general model stalls: technical documents, instrument readings, regional languages, industrial imagery, proprietary formats.
01Overview
TrainingMost custom models do not need pretraining from zero. We start from what your corpus actually contains, choose between continued pretraining, fine-tuning and distillation on that evidence, and size the model to the hardware it will run on.
01/ 02
Training
The data decides the method, not the other way round.
Most custom models do not need pretraining from zero. We start from what your corpus actually contains, choose between continued pretraining, fine-tuning and distillation on that evidence, and size the model to the hardware it will run on.
- 01
Pretrain or continue, decided by the data
We profile the corpus first: how much of it exists, how far it sits from what public models already know, and what the task needs. Continued pretraining on an open base is the usual answer; full pretraining is reserved for domains where the base helps less than it costs.
- 02
Small models sized to the task
A classifier, an extractor or a domain assistant rarely needs a frontier-scale model. We train and distil models that fit one GPU, a CPU server or a device, so serving is a line item you can read rather than a bill you cannot.
- 03
Multimodal where the work is
Instrument traces, scans, photographs, audio and text often arrive together. We build models that take the inputs your process produces, rather than forcing everything through text first.
- 04
Tokenisers and corpora built for your domain
Part numbers, chemical names, legal citations and regional scripts tokenise badly on general vocabularies. We build the tokeniser and the cleaned, deduplicated corpus as deliverables in their own right, with the provenance of every source recorded.
02/ 02
Ownership
Planned before the first job, yours after the last.
A model is a run log, a set of checkpoints, an evaluation history and a serving path, not a single file. We plan the compute, keep every run reproducible, and hand over weights, code and the retraining recipe under your name.
- 05
Compute planned before a job is queued
Every training plan carries a compute budget: hours, hardware, checkpoints and the point at which we stop and evaluate. You see the number before the job starts, and the run stops itself at the limit.
- 06
Checkpoints, evaluation and the run log
Each run is logged with its data snapshot, configuration and metrics, and evaluated against a held-out set from your own work at every checkpoint. A model can always be traced back to what it was trained on.
- 07
Weights that belong to you
The weights, tokeniser, training code and evaluation harness are delivered into your repository and your storage. There is no dependency on us to keep the model running.
- 08
Serving and retraining after the first release
The model ships with a serving path sized for your traffic and a retraining recipe that runs when the data moves. Whether we operate it or your team does, the loop is documented from the start.
At a glance
Every capability, at a glance
8 figures, one per capability. Open any to read it in full.
How it runs
From first call to running unattended
Every engagement runs the same five steps, whatever the service.
- 01
Map the process
We sit with the people who do the work today and write down every step, exception and hand-off before anything is built.
- 02
Build against a golden set
A held-out set of real cases, agreed with you, is the bar each build has to clear before it goes anywhere near production.
- 03
Run beside the team
The system runs in parallel with the team for as long as it takes, and every disagreement between them is reviewed together.
- 04
Hand over the keys
The code, the prompts, the evaluation set and the runbooks are handed over in your accounts, under your keys.
- 05
Keep it running
We watch the runs, retrain and repair as the inputs drift, or train your own team to do the same.
Outcomes
What this looks like when it lands.
01 A domain model that fits the hardware you have
A small model trained on your corpus, serving from one server, replacing an external API call for the task it was built for.
02 A corpus and tokeniser you can build on again
The cleaned, deduplicated corpus and the domain tokeniser outlast any single model and shorten the next one.
03 A retraining loop your team can run
Data moves, the recipe reruns, the evaluation gate decides whether the new checkpoint ships.
Details
On the spec sheet.
- Service
- Custom Model Development
- Group
- Models & intelligence
- Capabilities
- 8
- Engagement
- Map, build, run beside the team, hand over, keep running
- Ownership
- Your accounts, your keys, your region
Questions we are asked about custom models
Asked before signing.
Do we need to pretrain from scratch?
Almost never. Continued pretraining or fine-tuning on an open base covers most domains at a fraction of the compute. We recommend full pretraining only when the corpus profile shows the base is a hindrance rather than a head start, and we show you that evidence before proposing it.
How much data is enough?
It depends on the task and the distance from what public models already know. We profile the corpus in the first week and tell you what is achievable with what you have, and what more data would change.
Who owns the model?
You do. Weights, tokeniser, training code and the evaluation harness are delivered into your accounts and repositories. We keep nothing you would need to run it.
Where does training run?
On your cloud accounts or on hardware you nominate. Data stays in the region you require, and the compute is billed to you directly so the cost is visible.
What happens when the data changes?
The retraining recipe reruns on a cadence you agree or when drift is detected, and a new checkpoint ships only if it passes the same evaluation gate as the first release.
Start