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. Instructions and memory travel with you anywhere. What the model has learned belongs to that exact model. What really survives a swap unharmed is the dataset behind it.
In the instruction
holds for this one conversation
Baked into the model
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 behind it is reusable: when a better base model arrives next year, we train again from it. It still needs maintaining, products change, tone changes, and old examples eventually encode behaviour nobody wants any more. That is why it is yours, in writing, with its version history.
Your data never enters a shared model
Every customer gets their own training run and their own result. There is no StudioMeyer model assembled from everybody's customer data. That is not a setting, that is how it is built.
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.
Training 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
Instruction
The rule sits in the text the model receives with every request. Costs nothing, changes instantly, but holds only for that one conversation.
- 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 repeatedly. Then the model learns the behaviour for good.
- 4
Shrinking it down
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 model. Some are right in the instruction, some in memory, some need a hard guard outside the model. We sort that out before the first training run.
Knowledge
What is stable in your business: what things are called, which cases exist, how you tell them apart, which internal terms apply. 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. Training raises the hit rate; the guarantee comes from an enforced schema plus a validation pass afterwards, anything that does not fit is caught rather than shipped.
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. First we try fewer tools, better descriptions and worked examples, where that is not enough, training makes the choice and the parameters markedly steadier.
It does not solve this
Fresh or changing knowledge
Prices, stock, appointments belong in memory, not in the model. What changes gets looked up.
Small does not become clever
A small model becomes narrower and more reliable, not smarter. Anyone claiming training turns a small 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 held-out examples nobody knows anything
Without examples set aside beforehand 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. This list is for people who want the detail. You do not have to follow it, anyone who knows the stack can check every number with it.
- Base model
- An openly licensed model whose licence permits the intended use, often Apache 2.0, sometimes a vendor licence with conditions. Which one it is goes into the quote by name, version and licence. The choice follows the task and the hardware, not fashion.
- QLoRA + SFT
- Our standard case. On our technical assessment so far it carries the large majority 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 already forms in the first stage from the examples, here it gets sharpened between better and worse.
- 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. Afterwards you get a short deletion record: instance terminated, volumes deleted, no snapshots taken, local copies removed, plus the provider retention periods.
- Evaluation
- Checked against examples 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 goal, set the check examples aside 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
Instruction and memory are measured against those same examples. If that is enough, the project ends here, in your favour.
- 03
Build the dataset
The most honest point on this page: when planning we budget a third to a half of the effort for pure data preparation, an experience value from the literature and our own runs, not a measurement across a customer base. Examples come from real operations, carry origin and date, and are versioned like source code.
- 04
Choose the method and the base model
The base model itself stays untouched. What it learns lands in a small separate file of a few hundred megabytes that sits on top of it. So no new model is created, just an add-on for an existing one.
- 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 examples set aside
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 an instruction applies anew on every request and ends with the conversation. 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 thousands of 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 result is 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 result. 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 scope 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 examples from your own work, 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.