# OpenAI ends new fine-tuning jobs Jan 6: tune elsewhere or prompt?

URL: https://infro.io/blog/openai-ends-new-fine-tuning-jobs-jan-6-tune-elsewhere-or-prompt
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-18
Last modified: 2026-11-18
Last reviewed: 2026-11-18 (next review due 2026-12-18)
Topic: Evaluation and models
Format: Analysis

> OpenAI stops new self-serve fine-tuning jobs for active existing customers on 6 January 2027; existing tuned models keep serving until their base model's shutdown date[^openai-deprecations]. Choose between a last job, tuning elsewhere and prompting by running the same frozen eval on each and comparing cost per successful task.

Key takeaways:
- From 6 January 2027, active existing customers cannot create new OpenAI fine-tuning jobs; inference on a tuned model continues until its base model is deprecated, and tuned versions follow the base's shutdown date.
- For tunes on GPT-4o or GPT-4.1 snapshots, the 14 January 2027 base shutdown arrives eight days after the job cutoff, so a last job there buys almost nothing.
- Judge every path on one frozen eval and compare cost per successful task: all monthly costs, including hosting and failed attempts, divided by tasks that pass.
- Tuning elsewhere means a new clock: Azure's training and deployment dates, or open weights whose serving cost is fixed GPU time rather than per token.
- Prompting plus caching often closes small gaps; a tune that encodes labels or private knowledge usually needs retraining on a base that still accepts it.

## What OpenAI actually changed

OpenAI's deprecations page lists "self-serve fine-tuning job creation" as a restricted feature with a shutdown date of 6 January 2027, announced on 7 May 2026. The timeline underneath has three steps. On 7 May 2026, organizations that had never run fine-tuning lost the ability to create jobs. On 2 July 2026, so did organizations that had not run inference on a fine-tuned model in the past 60 days. On 6 January 2027, "active existing customers will no longer be able to create new fine-tuning jobs"[1].

The same page states what does not change on that date: inference on fine-tuned models continues until the underlying base model is deprecated, and fine-tuned versions of listed models follow the same shutdown schedule as their base[1]. So two clocks run separately. The job clock ends 6 January 2027. The serving clock ends on the base model's shutdown date.

From today, 18 November 2026, the first clock has 49 days left. For tunes built on the GPT-4o and GPT-4.1 snapshots, the second one ends 14 January 2027, 57 days out, with gpt-6-luna as OpenAI's recommended replacement[1]. That replacement is listed as not supporting fine-tuning[2]. The base-retirement angle is covered in [your fine-tuned model's base is retiring](https://infro.io/blog/your-fine-tuned-model-s-base-is-retiring-what-to-do-before-cutoff); this piece is about the other decision: what you do with the ability to tune at all.

## What happens to existing tuned models

Split your `ft:` model ids into two groups by base.

- **Base already on the deprecation list.** The tune dies with its base. For the GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini snapshots that is 14 January 2027[1]. The 6 January cutoff is almost irrelevant: a model you tune on the last day serves for about a week.
- **Base with no announced shutdown.** The tuned model keeps answering, but it is frozen. After 6 January you cannot refresh it with new labels, fix a regression in the training set or retrain after the base is updated. When OpenAI later announces that base's deprecation, you will be migrating without the option to retrain on the same platform.

Two other facts matter. OpenAI's notice policy promises at least six months for generally available models[1], which gives you a floor for planning the second group. And you can read `shutdown_date` from `GET /v1/models` for each model[1], so a nightly job can alarm on it instead of waiting for an email.

Do not count on a rescue. The OpenAI page describes no automatic upgrade for a retired id, and on Azure, fine-tuned workloads cannot be auto-upgraded and retirement dates are not extendable[3].

> **Warning: Check what you hold before you decide**
> A tuned model is weights you cannot take with you. What you can take is the training file, the validation file and your production logs. If those are gone, every option below except prompting starts from collecting data again.

## Three paths, and what each one is for

| Path | Choose it when | Main risk |
| --- | --- | --- |
| One last OpenAI job before 6 January | The base has no announced shutdown, and you need a refresh (new labels, a fixed training set) | The result is frozen, and the base's own deprecation arrives later with no retraining option on OpenAI |
| Tune elsewhere: Azure or an open-weight model | The behavior lives in the weights (labels, private knowledge) and prompting misses the pass mark | A new clock, new serving costs, new eval |
| Prompt a base model, with caching | The tune mostly fixed format, tone or a schema | Longer prompts; per-request cost rises with few-shot examples |

On "tune elsewhere", Microsoft's Foundry overview is the one vendor page I could read in full. It lists supervised fine-tuning for gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini and gpt-4.1-nano, reinforcement fine-tuning for o4-mini, and gpt-5 reinforcement fine-tuning by invitation only. It also lists open models with supervised fine-tuning: Llama-3.3-70B-Instruct, Qwen3-32B, gpt-oss-20b, Ministral-3B and several previews[4]. Microsoft's own caveat applies to the open ones: a method or tier that works for one model "isn't automatically supported for another", and an adapter "isn't interchangeable across similarly named base models"[4].

Azure's clocks are later but still finite. Fine-tuned GPT-4.1-family models retire training no earlier than 14 April 2027 for existing customers, and deployment on 14 October 2027; for GPT-4o and GPT-4o mini the dates are 1 April and 1 October 2027[2]. Tuning a GPT-4.1 on Azure today therefore buys months, not years. If the target is an open-weight base, the retirement risk moves from the vendor's deprecation page to your own upgrade plan.

## Compare on cost per successful task

Per-token rates cannot choose between these paths, because a tune moves cost into three other places: training, hosting and the prompt. Use one metric across all candidates: monthly cost of everything that serves the task, divided by the tasks that pass the eval. The general method is in [cost per successful task](https://infro.io/blog/cost-per-successful-task); the terms specific to this decision are these.

- **Training**, amortized over the months the tune will live. Azure bills supervised fine-tuning as training tokens × epochs × the training rate, and does not charge for queue time, failed jobs or jobs canceled before training starts[5]. Include reruns: Microsoft tells you to budget for repeated runs, grading and evaluation[5].
- **Hosting.** Azure's Standard and Global Standard deployments of tuned models add an hourly hosting fee to token charges; Developer deployments have no hosting fee but are for evaluation only and are removed after 24 hours[5]. Managed compute bills GPU-hours, and allocated capacity "incurs charges while the deployment runs, even when you aren't sending inference requests"[5].
- **Inference**, with the real prompt length. A tune lets you drop few-shot examples; prompting puts them back.
- **Failures.** Retries, human review of failed outputs and escalations count against the tasks that did not pass.

```python
def cost_per_success(
    inference: float,      # monthly token spend on this path
    hosting: float,        # fixed monthly serving charge, 0 if none
    one_off: float,        # training + eval work for this path
    months: int,           # how long the path will live
    tasks: int,            # monthly task volume
    pass_rate: float,      # from the frozen eval, 0..1
) -> float:
    monthly = inference + hosting + one_off / months
    return monthly / (tasks * pass_rate)
```

> **Example: Illustrative: 100,000 tasks a month**
> These figures are invented to show the arithmetic. They are not provider rates and not measurements.
> 
> | Path | Monthly spend | Pass rate | Cost per successful task |
> | --- | --- | --- | --- |
> | Existing tune, as is | $1,200 | 94% | $0.0128 |
> | Base model plus few-shot, no caching | $1,900 | 91% | $0.0209 |
> | Same prompt, with a prompt cache hit on the shared prefix | $1,300 | 91% | $0.0143 |
> | Open-weight tune on managed GPUs | $2,400 | 92% | $0.0261 |
> 
> The tune looks best until it is gone. The fair comparison is the three replacements with their one-off costs added. Here caching puts the prompted path within about a cent of the old tune, and the fixed GPU charge makes the open-weight tune worse at this volume.

The open-weight row flips with volume. A GPU charge is fixed while token spend is linear, so a high, steady volume can favor dedicated hardware and a spiky one will not. Provider-side prompt caching rules differ in write price and lifetime; see [prompt caching across providers](https://infro.io/blog/prompt-caching-break-even) before you assume a hit rate.

## Build the eval before choosing

Everything above depends on the pass rate, and a pass rate is only as honest as the set it is measured on. Keep the tune's validation split, add sampled production requests including the ugly ones, and add known failures. Keep training rows out of it; Microsoft's guidance is to keep validation and final test examples out of the training set[6], and its overview warns that benefits "aren't guaranteed" and that held-out evaluation is how you compare against a baseline[4]. Freeze the set and the pass mark before the first candidate runs.

A sensible order of work for the next seven weeks:

1. This week: list every `ft:` id, its base, its shutdown date and whether you still hold the training and validation files.
2. This week: if you lack recorded requests, turn on capture. It is not retroactive.
3. Weeks 1 to 2: freeze the eval and run the untuned base with a prompt and schema. If it clears the mark, stop here.
4. Weeks 2 to 4: if it misses by a small margin, add few-shot examples from the training set and a prompt cache; if by a lot, run a tune on an Azure or open-weight base.
5. Before 6 January: decide on any last OpenAI job. Run one only if the base has no announced shutdown and a refresh would change the pass rate.
6. Before the base's shutdown date: cut over with the old tune as the fallback until the last step. Fallback quality is its own test; see [is your fallback model good enough](https://infro.io/blog/is-your-fallback-model-good-enough-test-fallback-equivalence).

## Where a control plane helps

If your traffic already passes through INFRO on your own provider connections, the usage records group requests by model id, which finds every `ft:` caller, and the catalog records vendor shutdown dates and refuses a retired model before any provider call, naming the replacement. Datasets built from logged requests, experiments that run up to six variants over a dataset with a stated spend cap, and evaluators on your own account cover the comparison step; versioned prompts keep the few-shot variant rollback-able. INFRO sees request metadata, not answer quality, so the pass mark is still yours to set. It does not tune anything. The docs overview is at [infro.io/docs](https://infro.io/docs)[7].

The decision itself is small. Do not tune because you could until 6 January; tune only if a frozen eval shows prompting and caching cannot reach the mark, and then pick the platform whose retirement dates outlast the feature's useful life.

## Questions

### Does my existing fine-tuned model stop working on 6 January?

No. OpenAI states inference on fine-tuned models continues until the underlying base model is deprecated, and that only job creation ends on 6 January 2027 for active existing customers.[1] The date that matters for serving is the base model's shutdown date.

### Can I keep a fine-tuned model running after its base shuts down?

OpenAI says fine-tuned versions follow the same shutdown schedule as their base models. It also says that in some cases developers may be able to provision dedicated capacity for continued access after a shutdown date, through its sales team.[1] Treat that as a conversation to start early, not a plan.

## Sources

1. Deprecations (including the update to self-serve fine-tuning) — OpenAI. https://developers.openai.com/api/docs/deprecations (accessed 2026-11-18)
2. GPT-4o and GPT-4.1 shut down 14 January 2027: migration plan — INFRO. https://infro.io/blog/gpt-4o-gpt-4-1-shutdown-january-2027 (accessed 2026-11-18)
3. Your fine-tuned model's base is retiring: what to do before cutoff — INFRO. https://infro.io/blog/your-fine-tuned-model-s-base-is-retiring-what-to-do-before-cutoff (accessed 2026-11-18)
4. Training in Microsoft Foundry — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/fine-tuning/overview (accessed 2026-11-18)
5. Manage fine-tuning costs in Microsoft Foundry — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/fine-tuning/cost-management (accessed 2026-11-18)
6. Fine-tune a model with supervised fine-tuning in Microsoft Foundry — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/fine-tuning (accessed 2026-11-18)
7. INFRO documentation — INFRO. https://infro.io/docs (accessed 2026-11-18)
