Launch Your Own Branded AI Model: Fine-Tuning, Licences, Real Costs and Timeline (2026)
- A branded model is an open-weights base plus your data and your name. A LoRA run on a 27B model costs about $7 of GPU time on my arithmetic; the budget goes to 5,000 reviewed examples, an eval suite and $4,910 a month to serve a high-availability pair.
- The licence decides the name. Apache 2.0 and MIT bases such as Qwen3.8-27B, Gemma 4, gpt-oss and DeepSeek V4 let you ship Acme-1, Llama requires the name to begin with 'Llama', and Qwen's new Community License needs a separate licence for any Model-as-a-Service business.
- Say 'fine-tuned from', never 'trained from scratch'. Pre-training even a 7B model on 2 trillion tokens is about 67,000 H100-hours, roughly $235,000 of compute on my arithmetic, and DeepSeek priced its final V3 run alone at $5.576M.
- 1Pick a licensed baseread the licence file of the checkpoint
Apache 2.0 or MIT weights you may rename and sell: Qwen3.8-27B, Gemma 4 31B, gpt-oss-120b, DeepSeek V4-Flash.
- 2Build the datasetthe largest line in the budget
5,000 expert-reviewed examples for a fine-tune, or billions of tokens of domain text for continued pre-training.
- 3Train$7 a run to $4,671 a run
LoRA on one GPU, a full fine-tune on an eight-GPU node, or continued pre-training for about a week per 10B tokens.
- 4Evaluate and safety-testthe release gate
A golden set, a general-capability regression, a red-team suite and a guard model. Nothing ships that loses to the base model with a good prompt.
- 5Serve under your name$4,910 a month for an HA pair
vLLM with its served-model-name flag set to acme-1, behind your own keys, rate limits and usage metering.
- 6Publish the model cardwhat you can claim
Base model and licence, data summary, evals with dates, limits, intended use and every notice the licence requires.
What does it mean to launch your own branded AI model?
It means customers call a model with your name on it, say Acme-1 for insurance claims, from your app or your API, and it should beat a general model on your domain. In 2026 that model is almost always open weights you fine-tuned, served on GPUs you control, under a licence that permits the name.
Companies do it for four reasons, and each comes with a test. Differentiation: a named model with published scores on your domain is something a sales team can sell, if the scores beat what a customer gets from a frontier API with a good prompt. A data moat: years of labelled cases become weights a competitor cannot download, if the data is unique rather than public. Cost: a tuned smaller model can undercut per-token API prices at steady volume, if you can keep a GPU busy. Sovereignty: weights you hold, pinned to a version, in your jurisdiction; Mistral's August 2026 launch of in-region inference and European compute is a bet on exactly that demand.
Pick the name before the model, because the obvious one is weak. AcmeGPT is the usual pattern, and the US Patent and Trademark Office refused OpenAI's own application for GPT in February 2024 as merely descriptive, so you cannot own that part of your name either. OpenAI's brand guidelines also state that it does not permit its GPT brand in app, product, developer or company names. A coined name you can register, followed by a version number, ages better.
This post is a reference design built from published prices, licence texts and my arithmetic. It is not a case study of a model I have shipped for a client, and every estimate is labelled as one.
What does 'your own model' actually mean: fine-tuning, pre-training or distillation?
Four paths, cheapest first: LoRA or QLoRA adapters on an open base, a full fine-tune of every weight, continued pre-training on billions of tokens of domain text, and distillation of a large teacher into a small student. Training from scratch is a fifth path, and almost no product company should take it.
LoRA and QLoRA change behaviour: format, tone, task skill and how the model uses your vocabulary. LoRA freezes the base weights and trains small low-rank matrices, cutting trainable parameters by 10,000 times against full fine-tuning in the original paper, and QLoRA fine-tuned a 65B model on a single 48GB GPU. The data can be small: the LIMA authors fine-tuned a 65B model on 1,000 curated examples and it learned to follow specific response formats. Their own conclusion is that almost all knowledge is learned in pre-training, which is why facts belong in retrieval rather than in adapters.
A full fine-tune updates every weight and needs a node rather than a card: Hugging Face's launch post for Muse Glimmer 30B lists one 80GB H100 for LoRA and eight, with FSDP or ZeRO-3, for full supervised fine-tuning. Continued pre-training is different in kind. You keep training the base on raw domain text so it learns vocabulary and facts it never saw, and that takes billions of tokens: at about 0.75 words per token, 10 billion tokens is 7.5 billion words, roughly 15 million pages of 500 words. Count your pages before you choose this path. BloombergGPT went further: a 50B model trained from scratch on 363 billion financial tokens plus 345 billion general ones, on a budget of 1.3 million A100 GPU-hours.
Distillation trains a small student on a large teacher's answers, so you keep much of the teacher's behaviour at a fraction of the serving cost. Choose the teacher by its terms. DeepSeek's platform terms explicitly allow using outputs for model distillation (section 4.2), while OpenAI's terms of use forbid using output to develop models that compete with OpenAI and Anthropic's commercial terms (D.4) forbid using the services to train competing AI models. Distil from Llama and the Llama naming rule follows the student. From scratch is the path to rule out: DeepSeek priced the final V3 training run alone at $5.576M, excluding research and ablations.
| Path | What it changes | Data you need | Hardware for a 27B-class base | What you can truthfully say |
|---|---|---|---|---|
| LoRA or QLoRA | Format, tone, task behaviour | 1,000 to 10,000 reviewed examples | One GPU: 22GB for QLoRA, 64GB for 16-bit LoRA on a 27B model (Unsloth) | Acme-1, fine-tuned from Qwen3.8-27B |
| Full fine-tune | The same, deeper, with more risk of forgetting | 10,000 or more examples (my working range) | 8 x 80GB with FSDP or ZeRO-3 | Acme-1, fine-tuned from Qwen3.8-27B |
| Continued pre-training | Domain vocabulary and knowledge | Billions of tokens of domain text | 8 x 80GB for about a week per 10B tokens | Further pre-trained on 10B tokens of claims text |
| Distillation | A small model imitates a large one | 50M to 500M tokens of teacher answers (my working range) | Teacher inference plus a student fine-tune | Distilled from DeepSeek V4-Pro into a 12B student |
| From scratch | Everything | Trillions of tokens | Hundreds of GPUs for weeks (SmolLM3: 384 H100s, 24 days) | Trained from scratch, and only here |
Build the golden set first. It becomes your training data later, and it tells you whether training is needed at all.
One GPU, about $7 a run on my arithmetic, six weeks end to end.
An eight-GPU node for about a week per 10B tokens, 14 weeks end to end.
Teacher answers for about $495, a student that serves on 48GB cards.
About $235,000 of GPU time for a 7B model on 2 trillion tokens, before any failed run or any data work.
Which open-weights licences let you rename and sell a fine-tuned model?
Apache 2.0 and MIT let you rename, sell and serve a fine-tune as long as you keep the notices: Qwen3.8-27B, Gemma 4, gpt-oss, Mistral Small 4, Muse Glimmer, DeepSeek V4, GLM-5.3-Flash and MiMo-V2.6-Pro. Llama requires your model's name to begin with 'Llama'. Several 2026 licences add Model-as-a-Service clauses that bite exactly when you sell API access.
The Llama 4 Community License is explicit. Section 1.b.i says that if you distribute or make available a derivative, you must 'prominently display Built with Llama' on a related website, interface or documentation, and if you use Llama or its outputs to fine-tune a model you make available, you must 'include Llama at the beginning of any such AI model name'. So Llama-Acme-1 is allowed and Acme-1 is not. Section 2 requires a separate licence from Meta for companies with more than 700 million monthly active users at the version's release, and Llama 4's use policy withholds its multimodal models from companies based in the EU. Llama 3.3 carries the same naming clause.
The newer clauses target exactly this product. Qwen's Community License 1.0, used for Qwen3.8-Flash-Next, requires anyone conducting a Model as a Service business to obtain a separate licence before any commercial use, and defines that as giving a third party access to inference 'via API or a hosted endpoint' with meaningful control over the inputs or parameters. A branded model API is that from its first customer. Kimi K3 applies the same idea above $20 million of revenue over 12 months, Qwen's own Qwen3.8-Max License above $50 million, and GLM-5.3 only above $10 billion, where it asks for a security review. Mistral Medium 3.5's modified MIT grants nothing to a company with more than $20 million of monthly revenue, and MiniMax M3 requires 'Built with MiniMax M3' on any commercial use.
Permissive does not mean notice-free. Apache 2.0 requires you to pass on the licence and NOTICE file and to mark files you changed (section 4), and grants no trademark rights (section 6): you can say 'based on Gemma 4' but cannot brand with Gemma. MIT requires the copyright and permission notice. Gemma 3 and older remain under the Gemma Terms of Use, which make you pass their use restrictions on to your own customers as an enforceable provision. gpt-oss adds a one-line usage policy: comply with applicable law.
| Base model | Licence | Rename to your brand? | What you must show | Commercial limits |
|---|---|---|---|---|
| Qwen3.8-27B, Qwen3.6 | Apache 2.0 | Yes | Licence, NOTICE, changed-file notices | None |
| Gemma 4 (all sizes) | Apache 2.0 | Yes | Same; no Google trademarks | None |
| gpt-oss-20b and gpt-oss-120b | Apache 2.0 plus usage policy | Yes | Same | Comply with applicable law |
| Mistral Small 4, Mistral Large 3 | Apache 2.0 | Yes | Same | None |
| Muse Glimmer 30B | Apache 2.0 | Yes | Same | None |
| DeepSeek V4-Flash, V4-Pro, V4.1-Flash | MIT | Yes | Copyright and permission notice | None |
| GLM-5.3-Flash, MiMo-V2.6-Pro | MIT | Yes | Copyright and permission notice | None |
| Llama 3.3, Llama 4 | Llama Community License | Only as Llama-something | Built with Llama, licence copy, Notice file | 700M MAU; Llama 4 multimodal excludes EU-based licensees |
| Qwen3.8-Flash-Next | Qwen Community License 1.0 | Yes | Model name on your UI above 100M MAU or $20M monthly revenue | Separate licence for any Model-as-a-Service or AI work assistant business |
| Kimi K3 | Kimi K3 License | Yes | Kimi K3 on your UI above 100M MAU or $20M monthly revenue | Model-as-a-Service above $20M revenue in 12 months needs an agreement |
| GLM-5.3 | GLM-5.3 License | Yes | Copyright and permission notice | Model-as-a-Service above $10B revenue needs Z.AI's security review |
| Mistral Medium 3.5 | Modified MIT | Yes | Attribution notice | No rights above $20M monthly revenue |
| MiniMax M3 | MiniMax Community License | Yes | Built with MiniMax M3, plus a notice email | Written authorisation above $20M yearly revenue |
| Gemma 3 and earlier | Gemma Terms of Use | Yes | Pass-through use restrictions and the Gemma notice | Gemma Prohibited Use Policy |
How much data and GPU time does each path need?
Less GPU time than people expect, and more data work. On my arithmetic a LoRA run on a 27B model over 22.5M tokens is about 2 H100-hours, $7 at $3.49 an hour. Continued pre-training on 10B tokens is about 1,340 H100-hours, $4,671 a run. Reviewing 5,000 training examples at four minutes each is 333 expert-hours.
Start with memory. Unsloth's published minimums for a 27B model are 22GB of VRAM for 4-bit QLoRA and 64GB for 16-bit LoRA, so one 80GB H100 or 96GB RTX PRO 6000 is enough. Then compute: 5,000 examples of about 1,500 tokens for three epochs is 22.5M training tokens, and 4 x 27.8B x 22.5M is 2.5 x 10^18 operations, about 2 hours at 346 teraFLOPS. Twenty runs of hyperparameter and data iteration cost about $140. Together AI's managed fine-tuning lists $1.05 to $1.16 per million training tokens for LoRA on 17B to 69B models, $24 to $26 for a run of the same size.
A full fine-tune holds about 16 bytes per parameter in training with mixed-precision Adam (weights, gradients and optimiser state), about 445GB for 27.8B parameters, which is why it needs an eight-GPU node. The compute is still small: 150M tokens at 6 x 27.8B x 150M is about 20 H100-hours, $70. Continued pre-training is where GPU time becomes a real line: 10B tokens is 1.67 x 10^21 operations, about 1,340 H100-hours or seven days on one eight-GPU node, $4,671 per run. Budget three runs, because the first will teach you something about your data.
Data is the expensive line, and it is people. At four minutes of expert review per example and $80 an hour, my estimate, 5,000 examples cost $26,700, and a 400-question golden set at 15 minutes each adds $8,000. Distillation moves that cost to the teacher: 100,000 prompts with 1,500 input and 2,000 output tokens each on DeepSeek V4-Pro at off-peak rates ($0.66 per million input, $1.98 per million output) is about $495. For scale on the path to avoid, Hugging Face trained the 3B SmolLM3 on 11 trillion tokens with 384 H100s for 24 days: 221,184 GPU-hours, about $772,000 at $3.49 an hour.
What does the architecture of a branded model service look like?
Two halves joined by a model registry. The training half turns a licensed base model and your data into a candidate, and an eval harness decides whether it ships. The serving half runs the winner in vLLM under your model name, behind a branded API with keys, metering and a guardrail model, and publishes a model card.
The training half is mostly data engineering. A data pipeline pulls your domain data, removes duplicates and personal data, and records where every example came from, because a customer's security review will ask. For distillation, a teacher model writes answers into the same pipeline. The fine-tuning job itself is a known quantity: Axolotl, TRL and Unsloth all run LoRA and full fine-tunes, and the recipes are public, with Mistral's card pointing to Axolotl for Mistral Small 4 and Hugging Face's Muse Glimmer launch post including a TRL fine-tuning example.
The serving half is where your name appears. vLLM's served-model-name flag sets the model name returned in every API response and in /v1/models, so customers see acme-1 and never the base. If you trained adapters rather than full weights, the enable-lora and lora-modules flags serve them by name, and one base model can host several adapters, one per product line or large customer. In front sits your API gateway: keys, per-customer rate limits, usage metering into billing, a guardrail model on input and output, and logs you can hand to an auditor.
The registry is the part teams skip and later regret. Every candidate gets a version, the hash of its base checkpoint and licence file, the hash of its training data, its eval scores and its release decision. When a customer asks what changed between acme-1-2026-09 and acme-1-2026-12, the registry is the answer.
# Full fine-tuned weights, served under your own model name
vllm serve /models/acme-1-2026-09 \
--served-model-name acme-1 \
--max-model-len 32768 \
--api-key "$ACME_GATEWAY_KEY"
# One base model, several LoRA adapters served by name
vllm serve Qwen/Qwen3.8-27B \
--served-model-name acme-base \
--enable-lora \
--lora-modules acme-1=/adapters/acme-1-2026-09 acme-1-claims=/adapters/claims-2026-09 \
--max-loras 4 \
--max-lora-rank 64 \
--api-key "$ACME_GATEWAY_KEY"
# Clients see your names, never the base model
curl -s http://localhost:8000/v1/models -H "Authorization: Bearer $ACME_GATEWAY_KEY"How do you evaluate and safety-test a fine-tuned model before launch?
Against three baselines on a held-out golden set: the untouched base model, the base model with a good prompt and retrieval, and a frontier API. Ship only if the fine-tune beats the second on your tasks without losing general capability or safety, and re-run the safety suite on every candidate, because fine-tuning can erode safety behaviour.
The golden set is 300 to 500 real tasks, written and graded by people who know the domain, and never used for training. Grade with a model judge for speed, calibrated against a sample of human grades: the QLoRA authors found GPT-4 evaluations a cheap and reasonable alternative to human evaluation of chatbot quality, which is a licence to use a judge, not to skip the calibration. Add a general-capability check, a few public benchmarks run through EleutherAI's lm-evaluation-harness, to catch a fine-tune that learned your format and lost some of its reasoning.
Safety needs its own suite because fine-tuning moves it. Researchers showed that fine-tuning GPT-3.5 Turbo on 10 adversarial examples, for less than $0.20, removed its safety guardrails, and that fine-tuning on benign, commonly used datasets also degraded safety, to a lesser extent (Qi et al., 2023). So mix refusal examples into the training data, run a red-team set on every candidate, and put a guard model in the serving path: gpt-oss-safeguard (Apache 2.0) classifies against a policy you write, and Shieldstral 1.0 is a 3B Apache 2.0 classifier. The full threat model is part of LLM security.
Write the release gate as code, with a threshold per metric, and treat the prompt-plus-retrieval baseline as the one to beat. If the fine-tune cannot beat a well-prompted base model with retrieval over your documents, you have built an expensive way to ship the same answers, and the cheaper system is described in RAG over private documents.
- Beats the prompt-plus-retrieval baseline on the golden setThe only comparison that justifies the fine-tune. Losing to it means ship the baseline.
- No more than an agreed small drop on general benchmarksCatches a model that learned your format and lost reasoning it had before.
- Refusal rate on the red-team set at or above the base model'sFine-tuning can erode safety, even on benign data. This is where you see it.
- Guard model in the serving path, with a versioned policygpt-oss-safeguard or Shieldstral, tested against your own policy text.
- Model judge re-calibrated against 100 human grades this releaseThe step that gets skipped under deadline pressure, and the one that keeps the judge's scores tied to expert judgement.
- Model card updated with scores, run date and base checkpoint hashWhat customers and diligence teams read first.
How do you serve a fine-tuned model under your own name and publish a model card?
Run it on vLLM with the served-model-name flag set to acme-1, behind an OpenAI-compatible API gateway that issues keys, meters tokens and enforces rate limits. Then publish a model card that names the base model and its licence, summarises the training data, reports evals with dates, lists limits and intended use, and carries every notice the licence requires.
Serving costs the same as any private model. A high-availability pair of AWS g7e.2xlarge instances, each with one 96GB RTX PRO 6000 at $3.363 an hour, is $4,910 a month and holds a 27B model in BF16 with room for conversations; a distilled 12B model fits AWS's L40S-based g6e.xlarge at $1.861 an hour, $2,717 a month for a pair. Version the name (acme-1-2026-09), keep old versions live for a published deprecation window, and price per million tokens, the unit your customers already buy from API providers. Keeping per-request cost down is covered in LLM inference cost optimization.
A model card is a short public document, a format proposed by Mitchell et al. and standard on Hugging Face. For a branded model it should state the base model, its exact licence and the notices it requires (the Apache NOTICE file, the MIT copyright line, Built with Llama where it applies); the training data in categories rather than raw sources; intended and out-of-scope uses; eval results against the baselines with the date run; safety testing and known failure modes; and a contact for reporting problems.
In the EU, two rules matter. Article 50's duty to tell people they are interacting with an AI system has applied since 2 August 2026; the Digital Omnibus agreed in May 2026 moved the stand-alone high-risk rules to December 2027 but kept that date. And under the Commission's July 2025 guidelines for general-purpose AI models, a company that modifies a model becomes its provider only if the modification uses more than a third of the original training compute, or a third of 10^23 FLOP when that is unknown. The 10B-token pre-training run above is 1.67 x 10^21, about 5% of that fallback threshold. This is a summary, not legal advice.
What does a branded AI model cost, and how long does it take?
On my arithmetic: about $59,200 and 6 weeks for a LoRA model on a 27B base, about $137,000 and 14 weeks with continued pre-training, and about $59,800 and 10 weeks for a distilled 12B model, plus $2,717 to $4,910 a month to serve. GPU compute is at most about 11% of any path; people and data are the rest.
Path A is where to start. Five thousand reviewed examples, six engineer-weeks for the data pipeline, training runs, eval harness and serving, a 400-question golden set, and under $500 of GPU time. It tests the premise, that a tuned model beats a well-prompted one on your work, for the smallest cheque, and its golden set and pipeline carry straight into Paths B and C if the premise holds.
Path B only makes sense if you hold billions of tokens of domain text and the base model measurably lacks the domain's vocabulary or facts. It adds a corpus pipeline and three continued pre-training runs, and in my model doubles the reviewed dataset to 10,000 examples, because new domain knowledge still has to be taught to answer in your format. Path C is for cost and latency: a 12B student trained to answer like a much larger teacher, served on 48GB cards at $2,717 a month for a pair instead of $4,910.
Two inputs move these totals more than GPU prices. The expert rate, because $80 an hour for a claims reviewer is not the rate for a radiologist, and the number of iterations, because the first dataset is never the last. To see your own version of this table, price it in the AI product cost estimator.
| Line item | Path A: LoRA brand model | Path B: continued pre-training plus full fine-tune | Path C: distilled small model |
|---|---|---|---|
| Base model | Qwen3.8-27B or Gemma 4 31B (Apache 2.0) | Qwen3.8-27B (Apache 2.0) | Student Gemma 4 12B (Apache 2.0); teacher DeepSeek V4-Pro, whose terms allow distillation |
| Training data | 5,000 reviewed examples: 333 expert-hours at $80 = $26,700 | 10B domain tokens you already hold, plus 10,000 reviewed examples = $53,300 | 100,000 prompts and 200M teacher tokens = $495; 2,000 spot checks = $10,700 |
| GPU compute | 20 LoRA runs at about $7, plus eval inference: under $500 | 3 pre-training runs at $4,671, 10 fine-tune runs at $70, preference tuning and evals: about $15,700 | 8 student runs at about $80: $643 |
| Engineering | 6 engineer-weeks at $4,000 = $24,000 | 14 engineer-weeks = $56,000 | 10 engineer-weeks = $40,000 |
| Golden set and safety suite | 400 tasks, 100 expert-hours = $8,000 | $12,000, adding domain knowledge probes | $8,000 |
| One-off total | about $59,200 | about $137,000 | about $59,800 |
| Serving, high-availability pair | 2 x g7e.2xlarge = $4,910 a month | 2 x g7e.2xlarge = $4,910 a month | 2 x g6e.xlarge (L40S 48GB) = $2,717 a month |
| Timeline | 6 weeks | 14 weeks | 10 weeks |
| GPU compute as a share of the one-off | under 1% | about 11% | about 2% |
- Week 1Scope, golden set and baselines
Choose five task types, write and grade 400 golden tasks, and score the base model, the base model with retrieval and a frontier API. This week decides whether the project continues.
- Weeks 2 to 3The dataset
Pull 5,000 candidate examples from your records, remove personal data, have experts review and correct them, and record where each came from.
- Week 4Training runs
About twenty LoRA runs across learning rates, ranks and data mixes, each scored on the golden set. The GPU bill for the week is about $140.
- Week 5Evals, safety and red-team
General-capability regression, refusal rate against the base model, judge calibration against human grades, and the guard model's policy.
- Week 6Serving, API and model card
vLLM under your model name, gateway keys and metering, a high-availability pair, the model card and the licence notices. Then the first customer call.
- Paths B and CWhat the longer paths add
Path B adds about eight weeks for the corpus pipeline, three pre-training runs and a larger dataset. Path C adds about four weeks for prompt mining, teacher generation and filtering.
What can you claim about a fine-tuned model, and when should you not build one?
Claim what is true, in writing: 'acme-1 is fine-tuned from Qwen3.8-27B on 5,000 expert-reviewed claims cases', with its eval scores and their date. Do not claim 'trained from scratch', 'our own foundation model' or benchmark wins you cannot reproduce. And do not build one at all if a frontier API with retrieval already meets your quality bar.
Overclaiming is a legal risk, not only a reputational one. In March 2024 the SEC settled 'AI washing' charges against two investment advisers, Delphia and Global Predictions, for $400,000 in combined penalties over false claims about their use of AI, and Section 5 of the FTC Act covers deceptive claims in any US marketing. The base model is also one of the first facts technical due diligence establishes. I have done that work for institutional investors for more than three years, and 'a fine-tune of an Apache 2.0 base, on data nobody else has' is a perfectly good answer to give.
Do not build a branded model when prompting and retrieval on a strong model already pass your golden set, when you have fewer than about 1,000 reviewed examples, when your volume will not keep a GPU busy (a $4,910 serving bill buys a lot of API tokens), or when you cannot re-run the pipeline on a newer base. Qwen alone released open weights for versions 3.5, 3.6 and 3.8 between February and August 2026, and a fine-tune you cannot repeat on next quarter's base becomes last year's model with your name on it.
If the arithmetic says build, private LLM infrastructure is the service that covers the fine-tuning pipeline, evals and serving under your name, and it is built at $0: the work is split into checkpoints with acceptance criteria agreed before work starts, each invoiced only after you have seen it and accepted it.
- acme-1, fine-tuned from Qwen3.8-27B (Apache 2.0)
- Trained on 5,000 expert-reviewed claims cases from our own records
- Scores on our claims benchmark against named baselines, with the date run
- Built with Llama, whenever the base model's licence requires it
- Trained from scratch
- Our own foundation model
- Beats every frontier model, with no task, harness or date
- Proprietary model, with no mention of the base it was tuned from
Launching your own branded AI model: common questions
→How much does it cost to create your own branded AI model?
On my arithmetic, about $59,200 one-off for a LoRA fine-tune of a 27B open model, covering 5,000 expert-reviewed examples, six engineer-weeks and a 400-task golden set, plus about $4,910 a month to serve a high-availability pair on AWS. Adding continued pre-training raises the one-off to about $137,000. GPU time is under $500 of the first figure.
→Can I rename an open-source model and sell it under my own brand?
Yes, if the licence is Apache 2.0 or MIT, as for Qwen3.8-27B, Gemma 4, gpt-oss, Mistral Small 4, DeepSeek V4 and GLM-5.3-Flash, provided you keep the licence and notices. Llama requires the name to begin with 'Llama' plus a 'Built with Llama' notice. Qwen's Community License 1.0 and Kimi K3's licence add Model-as-a-Service clauses that affect API businesses.
→Is fine-tuning the same as training your own model?
No. Fine-tuning adapts an existing model's weights with your examples; training from scratch builds every weight from raw text. The gap is more than four orders of magnitude of compute: on my arithmetic a LoRA run on a 27B model is about 2 H100-hours, while pre-training even a 7B model on 2 trillion tokens is about 67,000. Describe a fine-tune as a fine-tune.
→How much training data do I need to fine-tune a model for my industry?
For behaviour, format and task skill, 1,000 to 10,000 reviewed examples; the LIMA authors fine-tuned a 65B model on 1,000 curated examples and it learned to follow specific response formats. For new domain knowledge, fine-tuning is the wrong tool: put facts in retrieval, or use continued pre-training, which needs billions of tokens of domain text. Hold back 300 to 500 examples as a golden set you never train on.
→Does fine-tuning make me a general-purpose AI model provider under the EU AI Act?
Usually not. The Commission's July 2025 guidelines treat a modifier as the model's provider only if the modification uses more than a third of the original training compute, or a third of 10^23 FLOP if that is unknown. A 10B-token pre-training run on a 27B model is about 5% of that fallback. Article 50's AI-interaction disclosure still applies from 2 August 2026.
→Should I call my model something-GPT?
I would not. The USPTO refused OpenAI's own GPT trademark application in February 2024 as merely descriptive, so the GPT part of your name gives you weak protection, and OpenAI's brand guidelines say it does not permit its GPT brand in app, product, developer or company names. A coined name you can register, plus a version number, ages better.
Open the article in your assistant with one click and ask it how this applies to your product.