OpenAI is closing its self-serve fine-tuning platform. Eligible existing customers can create training jobs only until January 6, 2027, and on January 14 the fine-tuned versions of GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini shut down along with their base models. A fine-tuned model is a standard OpenAI model given extra training on your own examples, so that it does one job your way. If your product calls one, this is a seven-week plan to replace it, with a script for each step.
Originally published at overmindlab.ai.
The weights, the learned numbers that make up the model, stay with OpenAI, but the data is yours. That covers the examples you trained on, the test cases you judged the model with and the production requests it has answered since, and it is enough to train a replacement that you own. It is like closing a restaurant in a rented building. The kitchen stays with the landlord, but the recipes and the record of what customers ordered are yours, and they are enough to reopen somewhere else. Start now, because the old model is the bar the new one has to clear, and you can only measure it while it still answers.
What is changing, and when?
| Date | What changes |
|---|---|
| May 7, 2026 | Organizations that had never run fine-tuning can no longer create fine-tuning jobs. |
| July 2, 2026 | Organizations with no fine-tuned inference in the past 60 days can no longer create jobs. |
| October 23, 2026 | GPT-3.5 Turbo (0125), GPT-4 (0613), GPT-4.1 nano and o4-mini shut down, and their fine-tuned versions with them. |
| October 31, 2026 | The OpenAI Evals platform becomes read-only. |
| November 30, 2026 | The OpenAI Evals dashboard and API shut down. |
| January 6, 2027 | Existing customers can no longer create new fine-tuning jobs. |
| January 14, 2027 | GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini shut down, and their fine-tuned versions with them. |
OpenAI fine-tuning and Evals wind-down, checked November 9, 2026
The dates come from OpenAI's deprecations page and its supervised fine-tuning guide. A fine-tuned model keeps answering until its base model shuts down, so check the base of each model you run against the table.
If your test cases live in OpenAI Evals, your deadline comes sooner, because the Evals API shuts down on November 30.
1. Audit what you run today
Before you rebuild anything, write down what the old model does and how well it does it.
- Which fine-tuned models does your code call? Search code and config for model IDs that start with
ft:, then match each one to its job, base model and training file. - How much traffic does each one get? Note requests per day, typical input and output length, and the latency your product needs. This decides how large a replacement you can afford to run.
- Where is the training data? Find your own copy of every training file, and note who wrote the answers in it, whether your team, a labeling vendor or a model.
- How do you know it works? Find the test set and the score the fine-tune gets on it. If there is no test set, building one is the first job, while the model still answers.
- Which API features do you rely on? Note whether you call Chat Completions or the Responses API, and whether you use tool calls, structured outputs or streaming. The replacement has to support each one.
This script lists every fine-tuned model in your organization with its base model and training file ID.
list_finetunes.py
from openai import OpenAI
client = OpenAI() # reads OPENAI_API_KEY
# The SDK pages through every job.
for job in client.fine_tuning.jobs.list(limit=100):
if job.fine_tuned_model:
print(job.fine_tuned_model, job.model, job.training_file, sep="\t")
Keep a local copy of every file on that list. OpenAI's API reference says the training data can be retrieved with the Files API, but an OpenAI staff reply on its forum in 2021 said files uploaded for fine-tuning can't be downloaded, and a developer reported the same there in 2025. Look for your own copy first. If you need the API, test it now rather than in January.
2. Collect the data you own
OpenAI's fine-tuning docs describe no way to export a fine-tuned model's weights, so the model itself stays behind. You can collect the data around it.
- Your training files hold one conversation per line, each ending in the answer you wanted. They are already in the chat
messagesformat that open-weight training tools accept. - Your test cases need exporting from wherever they live. If that is OpenAI Evals, export them before November 30. OpenAI's own migration guide points to Promptfoo.
- The requests your fine-tune has answered in production show what real inputs look like today, which your original training set may not. If your Chat Completions calls were stored (with
store: true, or by default on newer accounts),client.chat.completions.list(model=...)lists them with the model's replies, andclient.chat.completions.messages.list(completion_id)returns the messages you sent. OpenAI documents no retention period for them, so export them now.
Production traffic needs care, because the replies in it were written by an OpenAI model. OpenAI's usage policies, effective November 20, 2026, say you must not use OpenAI models or their outputs "to generate, prepare, select, or supply training material or signals for models that are intended as alternatives to or substitutes for OpenAI models or services." The inputs your users sent are not OpenAI outputs, and neither are answers your own team wrote from scratch. An answer your team corrected from a model's draft is a grey area. If you're not sure which kind of data you have, ask your legal team before you train on it.
3. Rebuild the dataset from your own records
Apart from the policy, there is an engineering reason to take your training targets from your own records. A model trained on the old model's replies learns the old model's mistakes along with everything else. The answer a person on your team accepted, or the final outcome in your system of record, is a better target than whatever the model said.
The script below assumes you log each request with the messages you sent and, where one exists, the answer your team accepted. It skips requests with no accepted answer and drops repeated inputs, keeping the first answer. Then it holds out about one conversation in five for testing (none if you have fewer than five), so that no conversation ends up on both sides. In a conversation with several turns, the earlier assistant messages were written by the OpenAI model. Replace them with the answers your team accepted for those turns, or leave those rows out, before you train.
build_dataset.py
import hashlib
import json
import random
examples, seen = [], set()
for line in open("requests.jsonl"):
row = json.loads(line)
# Written or approved by a person, or taken from your records.
accepted = row.get("accepted_answer")
if not accepted:
continue
key = json.dumps(row["messages"], sort_keys=True)
fingerprint = hashlib.sha256(key.encode()).hexdigest()
if fingerprint in seen:
continue
seen.add(fingerprint)
examples.append({
"conversation": row["conversation_id"],
"messages": row["messages"]
+ [{"role": "assistant", "content": accepted}],
})
conversations = sorted({e["conversation"] for e in examples})
random.Random(0).shuffle(conversations)
held_out = set(conversations[: len(conversations) // 5])
with open("train.jsonl", "w") as train, open("test.jsonl", "w") as test:
for e in examples:
out = test if e["conversation"] in held_out else train
out.write(json.dumps({"messages": e["messages"]}) + "\n")
requests.jsonl stands in for however you log requests. If yours sit in an observability tool, export them first. How to fine-tune a model on your agent's traces has export scripts for Langfuse and LangSmith, and how to turn traces into a training dataset covers sampling and labeling.
Then merge the result with your original training file and remove duplicates across the two. Before you train, read 50 rows at random. Check that every kind of request your product handles shows up, and that no test input also sits in the training file. OpenAI's fine-tuning guide recommends starting with 50 well-crafted examples, and its best practices expect a similar gain each time you double the count. You can test that on your own data. Train on half of it, then all of it, and keep adding examples only while the test score keeps rising.
4. Pick an open-weight base model
An open-weight model's weights are public, so you can train it and run it wherever you like, within its license. Your fine-tune did one narrow job, and a smaller open model trained on that job can often match it. In Overmind's contract review benchmark, a small model trained with Overmind scored 91.6% against a frontier flagship's 82.0% on 4,000+ questions across 100+ contracts, and cost 20x less to run. The score is F1, which penalizes both missed clauses and false alarms.
Other published results point the same way. LoRA is a way of fine-tuning that trains a small add-on, called an adapter, and leaves the original weights untouched. In LoRA Land, a 2024 technical report from the fine-tuning company Predibase, the best LoRA fine-tune of ten small open models beat GPT-4 on most of 31 tasks, many of them classification. GPT-4 stayed ahead on 6 broader tasks, such as Python coding.
The table lists six models you could start from. A parameter is one of the model's learned numbers, and the count (2B means two billion) is a rough measure of size.
| Model | Parameters | License | Context window | Weights at 16-bit | Worth knowing |
|---|---|---|---|---|---|
| Qwen3.5-2B | 2B | Apache 2.0 | 262K tokens | About 4.5 GB | Small enough for classification and routing |
| Llama 3.1 8B Instruct | 8B | Llama 3.1 Community License | 128K tokens | About 16 GB | Custom license with naming and attribution rules |
| Qwen3.5-9B | 9B | Apache 2.0 | 262K tokens | About 19 GB | A common next step up from 2B |
| Gemma 4 12B | 12B | Apache 2.0 | 256K tokens | About 24 GB | Reads text, images and audio |
| gpt-oss-20b | 21B, 3.6B active | Apache 2.0 | 131K tokens | About 42 GB | OpenAI's open-weight model; ships 4-bit to fit 16 GB |
| Qwen3.8-27B | 27B | Apache 2.0 | 262K tokens | About 56 GB | Needs an 80 GB GPU at 16-bit |
Six open-weight base models Overmind can train, from their Hugging Face model cards, November 9, 2026
Licenses, sizes and context windows come from the model cards for Qwen3.5-2B, Llama 3.1 8B Instruct, Qwen3.5-9B, Gemma 4 12B, gpt-oss-20b and Qwen3.8-27B. Weights at 16-bit is the checkpoint's full parameter count on Hugging Face, vision parts included, times two bytes. A host may serve a shorter context window than the model card states, so check its limit.
Running cost falls with size, though not always below what you pay today. OpenAI's pricing page charges twice the base rate to run a fine-tuned GPT-4.1 mini or GPT-4o mini. On OpenRouter, which lists several hosts' prices for the same open models, the base Qwen3.5-9B's list price per output token on November 9, 2026 was about 13x lower than OpenAI's price for a fine-tuned GPT-4.1 mini, and gpt-oss-20b's about 36x lower. Qwen3.8-27B's was higher than a fine-tuned GPT-4o mini's. Each host prices a fine-tuned copy on dedicated hardware differently, so treat these as a guide to scale.
Train the smallest model that passes your test set. Try two sizes at once, such as a 2B and a 9B, and move up only if both fall short. Size also decides the hardware you need. To serve a model at 16-bit precision, each billion parameters takes about 2 GB of GPU memory, plus room for the requests in flight. Training needs more.
5. Prove the new model matches the old one
Decide what "as good as" means before you look at any results, then hold both models to it.
- Freeze a test set made up of held-out production requests (split by conversation), your original test cases and a short list of hard cases, such as past incidents and the requests that cost the most when they go wrong.
- Score both models with the same checks. Exact match or F1 works for labels and extracted fields. For JSON, check that it parses and fits your schema. For free text, use an LLM judge with a short rubric of yes-or-no checks, and compare a sample of its verdicts with human ones.
- Score your OpenAI fine-tune on the full test set now and save its replies and scores, because after January 14 you can't run it again.
- Write the pass rule down. For example, switch only if the new model is within one point of the old one overall, misses none of the hard cases the old one got right, and returns valid JSON every time.
Both models speak the same API, so one script can score them. This version uses exact match, which suits labels and short extractions. It prints the two scores and nothing else, so write the old model's replies to a file as well.
parity.py
import json
import os
from openai import OpenAI
current = OpenAI() # your OpenAI fine-tune
candidate = OpenAI(
base_url="https://api.overmindlab.ai/api/v1",
api_key=os.environ["OVERMIND_API_KEY"],
)
# The model ID comes from list_finetunes.py.
CURRENT_MODEL = "ft:gpt-4.1-mini-2025-04-14:your-org::abc123"
CANDIDATE_MODEL = "your-deployment-model-id"
def accuracy(client, model, rows):
correct = 0
for row in rows:
reply = client.chat.completions.create(
model=model, messages=row["messages"][:-1], temperature=0
)
answer = (reply.choices[0].message.content or "").strip()
correct += answer == row["messages"][-1]["content"].strip()
return correct / len(rows)
rows = [json.loads(line) for line in open("test.jsonl")]
old = accuracy(current, CURRENT_MODEL, rows)
new = accuracy(candidate, CANDIDATE_MODEL, rows)
print(f"current {old:.1%}, candidate {new:.1%}")
assert new >= old - 0.01, (
"More than a point behind: fix the data and retrain."
)
6. Switch traffic without rewriting your app
If the new model sits behind an OpenAI-compatible endpoint, the switch is a configuration change. Your code keeps the OpenAI SDK and you change the base URL, the API key and the model name, the same way parity.py does above. Before you switch, check which OpenAI APIs your new host supports. Overmind's endpoint, for example, serves Chat Completions with streaming and tool calls but doesn't serve the Responses API, so any Responses calls have to move to Chat Completions first.
If you would rather run the model yourself, download the trained weights and serve them with an OpenAI-compatible server such as vLLM. After a LoRA run the download is an adapter that vLLM loads on top of the open base model it was trained from. vLLM accepts adapters up to rank 16 unless you raise --max-lora-rank, so set it to at least the r value in the adapter's adapter_config.json. The command below uses 64, which covers Overmind's default ranks of 16 and 32. Llama 3.1 is a gated model, so accept its license on Hugging Face and log in before you run this.
vllm serve meta-llama/Llama-3.1-8B-Instruct \
--enable-lora --max-lora-rank 64 \
--lora-modules support-router=./adapter
Either way, move traffic in stages. Start in shadow mode, where the new model answers a copy of each live request and users still see the old model's reply. Compare the two on live traffic, then move 5% of users, then half, then everyone. Keep the OpenAI model as the fallback until it shuts down.
How long does the move take?
From a mid-November start there are about eight and a half weeks before January 14, so seven working weeks fit with at most one week off. Weeks 6 and 7 fall over Christmas and New Year, so if your team takes a break of more than a week, start sooner. And if you want one last refreshed OpenAI fine-tune as a fallback, start that job before January 6.
| Week | What to do | Done when |
|---|---|---|
| 1 | Audit models, traffic and data. Export test cases from OpenAI Evals before it shuts on November 30. | Every ft: model has an owner, a training file and a test set |
| 2 | Rebuild the dataset, freeze the test split, and score the current fine-tune on it | train.jsonl, test.jsonl and baseline scores are saved |
| 3 | Train two sizes of open-weight model, such as a 2B and a 9B | Both are scored on the frozen test set |
| 4 | Fix the data where the candidate fails, then retrain | The candidate meets the pass rule |
| 5 | Shadow traffic: the new model answers copies of live requests | Live scores match the offline ones |
| 6 | Move 5% of traffic, then half | Product metrics hold steady |
| 7 | Move all traffic and keep the OpenAI model as a fallback | Nothing in production calls an ft: model |
A seven-week migration, assuming a start in mid-November 2026
Making the move with Overmind
Overmind covers the data, training, comparison and serving steps, and your coding agent can drive each one.
- Upload the JSONL file you trained on as it is. Overmind trains on the same chat
messagesformat, tool calls included. There is no one-click OpenAI import, so production traffic comes in through the Python SDK, OpenTelemetry or a Langfuse, LangSmith, Braintrust or Galileo connector. - Prepare the data in the Data Workshop, where your coding agent writes each preparation step as a small Python script. Overmind runs each script in an isolated sandbox, keeps every version and checks that each version fits the training format. When you split data into training and test sets, it removes exact duplicates and keeps rows from the same conversation on one side.
- Fine-tune any model in the table above with LoRA, or with full fine-tuning on models up to 14B.
- Compare the result. Overmind can score the trained model against its untouched base on your test set. It can't call a private OpenAI fine-tune, so score your fine-tune's saved replies with the same checks yourself.
- Call the model with the OpenAI SDK at
https://api.overmindlab.ai/api/v1, or download the weights from the model page or withovermind model download-checkpoint. Serverless deployments scale down when idle, so the first request after a quiet spell waits for a worker. For steady traffic, a dedicated GPU deployment lets you set the replica range.
If you have a fine-tuned OpenAI model in production, your coding agent can make this move for you. Open your product's repo in Claude Code, Cursor, Codex or OpenCode and paste Set me up on Overmind https://console.overmindlab.ai/setup.md into the chat. If there's no repo to hand, start for free and upload the JSONL file you trained on. The console then gives you a prompt for your coding agent that works without a repo.
FAQ
When does OpenAI fine-tuning shut down?
Eligible existing customers can create new fine-tuning jobs until January 6, 2027. A fine-tuned model keeps answering until its base model shuts down. For GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini, that is January 14, 2027.
Can I download my fine-tuned OpenAI model?
Not as far as OpenAI's documentation shows. Its fine-tuning docs describe no way to export a fine-tuned model's weights, and a fine-tuned checkpoint can only be shared with other projects in your own OpenAI organization. You keep your training files and test cases, and train a new model on them.
Can I train a new model on my fine-tune's replies?
Check the terms first. From November 20, 2026, OpenAI's usage policies bar using its outputs to prepare training data for models meant to substitute for OpenAI's. Inputs from your users and answers your team wrote from scratch are not OpenAI outputs. Answers corrected from a model's draft are a grey area, so ask your legal team if you're unsure.
Which open model should replace a fine-tuned GPT-4.1 mini?
Start with a small one. Train a 2B to 9B model on the same task and score it against your fine-tune on the same test set. Move to a larger model only if the small ones fall short.
Do I need to change my application code?
Very little, if the new model sits behind an OpenAI-compatible endpoint. You change the base URL, the API key and the model name. Calls to the Responses API need moving to Chat Completions first if your new host only serves Chat Completions.
Overmind is the model training platform for AI teams. Start for free.
Top comments (0)