Own models
A model that has learned how you work.
A good prompt explains your way of working to a stranger, every single time. Your own model has learned it. We train an open base model further on your knowledge — the dataset is yours and outlives every model swap.
The difference
Explaining, looking up, or knowing.
There are three places a rule can live. Only the third one survives a model swap.
In the prompt
holds until the next window
In the weights
holds without anyone writing it down
In memory
holds when someone searches for it
The dataset is the asset, not the model
A trained model ages, like every model. The dataset it came from does not. When a better base model arrives next year, we train again from the same dataset. That is why it is yours, in writing.
Your data never enters a shared model
Every customer gets their own training run and their own weights. There is no StudioMeyer model assembled from everybody's customer data. That is not a setting, that is the architecture.
No vendor lock-in
The base model is openly licensed, the result runs on your hardware or in your cloud. You do not need us to operate it. You need us if you want to develop it further.
Where it fits
Most of the time you do not need training.
Finetuning is for form, not for facts. There are four rungs, and each one only comes into play once the one below it has measurably failed, not felt wrong.
- 1
Prompt
The rule sits in the instruction. Costs nothing, changes instantly, holds until the next context window.
- 2
Memory
Knowledge that changes belongs here: prices, stock, customer history. Look it up rather than learn it in.
- 3
Training
Only once form, domain vocabulary or tool calls go wrong reproducibly. Then behaviour goes into the weights.
- 4
Distillation
A large model teaches a small one how to answer. For when it has to run small, fast and cheap.
We check first whether a good prompt and a memory are enough. In most cases they are, and then we say so, instead of selling a training run.
Four ways in
Where a rule lands decides whether it holds.
Not every rule belongs in the weights. Some are right in the prompt, some in memory, some need a hard guard outside the model. We sort that out before the first training run.
Knowledge
What your business knows: products, pricing logic, edge cases, the names that only mean something in your shop. Today that sits in a manual beside the model and gets sent along with every request.
After training the model knows it. Answers get shorter, faster, and less dependent on whether the right passage was retrieved.
Processes
How work is done at your place: in which order, with which intermediate steps, when a human has to sign off. Written out as a rulebook this gets longer than it helps.
As a learned sequence it needs no list. The model does it the way it was done in your examples.
Behaviour
How it answers: tone, length, limits. What must never be promised. When to ask instead of guessing. Exactly the part of a manual that gets ignored first.
Training behaviour means preferring and rejecting examples, not writing rules. Whatever has to hold absolutely, we additionally guard outside the model.
Robot connection
From the system's point of view a robot is just another client calling tools — like a chat window, only with arms. The interface is the same one we already build for connectors and systems.
The robot leaves eventually, the learned knowledge about your business stays. That is why we build it next to the robot, not inside it.
Straight
What training solves, and what it does not.
It solves this
An exact output schema
The same form, the same JSON structure, ten thousand times, without outliers.
Narrow domain vocabulary
Industry language, internal shorthand, standards, without anyone re-explaining them on every call.
Brand voice
Consistent, without a three-page prompt in front of every answer.
Reliable tool calls on small models
In practice the most important one: small models only get tool calls right reliably after training.
It does not solve this
Fresh or changing knowledge
Prices, stock, appointments belong in memory, not in the weights. What changes gets looked up.
Small does not become clever
A small model becomes narrower and more reliable, not smarter. Anyone claiming training turns an 8B model into a frontier model is selling you something false.
Learning has side effects
A model forgets elsewhere when it learns something new. You work against that with data mixing, but you have to know about it.
Without a held-out test set nobody knows anything
Without set-aside examples there is no way to tell whether a run improved something or broke it. This is where most projects fail.
With what
What we build it with.
Open models, traceable methods, nothing secret. Anyone who knows the stack can check every number.
- Base model
- An openly licensed model that permits commercial derivative work (Apache 2.0). The choice follows the task and the hardware, not fashion.
- QLoRA + SFT
- Our standard case, covering roughly 95 percent of projects: output format, domain vocabulary, voice and tool calls. We train an adapter, not the whole model. That keeps runs affordable and allows several specialisations on one base.
- DPO / SimPO
- Stage two, once supervised training holds. Sharpened on pairs following the pattern "A is better than B". Behaviour comes from this stage, not the first.
- GRPO / DAPO
- Reinforcement learning with a verifiable reward, in our case for the orchestrator. Only worthwhile when correctness is machine-measurable. With tool calls it is exactly that.
- Own hardware or rented GPU
- The run happens where the data is allowed to be. Locally for sensitive datasets, otherwise on rented GPUs that get wiped afterwards.
- Evaluation
- Checked against a test set from your actual work before delivery, not against a paper benchmark. No result without a comparison against the untrained model.
How it runs
Eight steps.
- 01
Define the target behaviour, build the test set first
Before the first line of training data comes the question: how will we know it worked? A set of examples is put aside and never touched during training.
- 02
Check whether it works without training
Prompt and memory are measured against that same test set. If that is enough, the project ends here, in your favour.
- 03
Build the dataset
The most honest point on this page: in company projects, 30 to 50 percent of total cost is pure data preparation. Examples come from real operations, carry origin and date, and are versioned like source code.
- 04
Choose the method and the base model
For roughly 95 percent of cases, QLoRA with supervised fine-tuning. The model itself stays untouched; learning happens in small additional matrices. The result is a file of a few hundred megabytes, not a new model.
- 05
Train on rented compute
No hardware of your own required. The card is rented by the hour and shut down afterwards.
- 06
Measure against the held-out test set
Before and after, with numbers. No gut feeling, no "it feels better".
- 07
Ship
One base model carries several specialists at once, each as its own small file. Instead of five models at 20 GB each, one model runs with five attachments.
- 08
Maintain
When a new model generation arrives, a new attachment is trained from the same dataset. That is exactly why the dataset is the asset and not the model.
FAQ
Frequently asked
Why not just write a better prompt?
Because a prompt applies anew on every request and ends with the context window. For many tasks that is enough, and then that is exactly what we recommend. Your own model pays off when the same explanation is sent a thousand times, or when a rule has to hold even when nobody writes it down.
Is it really your own model if you train an existing one further?
It is your own model in the sense that the weights are yours and came from your data. It is not a model built from scratch — nobody does that on a sane budget, and anyone claiming otherwise is selling you something else. The base model's licence explicitly permits commercial derivative work.
Does our data end up in a model other people use?
No. Every customer gets their own run and their own weights. There is no shared model made from customer data — not as a promise, but because that is not how we build it.
What does it cost?
The price follows the size of the dataset, not the compute time. Compute is the smaller line item. What costs time is sorting and preparing your material, and we can only see that once we have looked at it.
How do we know this works?
We run the method on our own orchestrator, the system behind the AI station. What we build for you runs in our own operation first. And it is measured against your own test set, not a paper benchmark: without a comparison to the untrained model we do not ship.
And what about n8n and workflow automation?
We build it wherever a process needs it. It is simply not on the shelf as a separate product; it comes as part of the system we build for you. The reason is simple: a single mail watcher does little if it does not know your business. That is what this page is about.
Next step
Which explanation do you send along every day?
Tell us what your model has to learn again every time. We will tell you honestly whether that belongs in training or in a better prompt.