# GPT-4o and GPT-4.1 API shutdown on January 14, 2027: dates, replacements, how to migrate

> Source: <https://www.evalshift.dev/blog/gpt-4o-gpt-4-1-deprecation>
> Published: 2026-11-17 21:41:45.270916+00:00

[← all posts](https://www.evalshift.dev/blog)

# GPT-4o and GPT-4.1 API shutdown on January 14, 2027: dates, replacements, how to migrate

GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini shut down on OpenAI's API on January 14, 2027. The snapshots, the gpt-6-luna replacement, how to migrate.

On OpenAI's API, GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini shut down on January 14, 2027.
OpenAI's deprecations page lists five snapshots for that date: `gpt-4o-2024-08-06`,
`gpt-4o-2024-11-20`, `gpt-4o-mini-2024-07-18`, `gpt-4.1-2025-04-14` and `gpt-4.1-mini-2025-04-14`.
The recommended replacement for all five is `gpt-6-luna`. OpenAI announced the shutdown on October
14, 2026, 92 days ahead, although its policy promises at least six months for generally available
models. Fine-tuned models built on these snapshots shut down the same day.

Changing the model string is not the whole migration:

- +**`gpt-6-luna` is a reasoning model.** Its reasoning effort defaults to`medium` . At any effort
above`none` , OpenAI says to remove`temperature` ,`top_p` and`top_logprobs` , and Chat
Completions supports function calling only at`none` . Reasoning tokens are billed as output and
count toward the output cap.
- +**Fine-tunes have no self-serve successor.**`gpt-6-luna` can't be fine-tuned, and from
January 6, 2027 existing customers can no longer start new self-serve fine-tuning jobs.
- +**The other dates you've seen are not this one.** ChatGPT dropped GPT-4o on February 13, 2026,
and Azure OpenAI runs most of these models until April 14, 2027. Neither applies to OpenAI's API.

The rest of this post covers every upcoming GPT-4o and GPT-4.1 date, what happens to the undated
`gpt-4o` and `gpt-4.1` names,
what changes in the request, and a six-step migration. The facts come from OpenAI's
[deprecations page ↗](https://developers.openai.com/api/docs/deprecations), its model and pricing
pages, its [GPT-6 guide ↗](https://developers.openai.com/api/docs/guides/latest-model), and Azure's
[retirement schedule ↗](https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-retirement-schedule),
all read on November 17, 2026. Check the page again before you act on a date.

## GPT-4o and GPT-4.1 shutdown dates on OpenAI's API

| Model ID | Shutdown date | Announced | Listed replacement | 
|---|---|---|---|
| `gpt-4o-2024-08-06` , the snapshot`gpt-4o` points to | January 14, 2027 | October 14, 2026 | `gpt-6-luna` | 
| `gpt-4o-2024-11-20` | January 14, 2027 | October 14, 2026 | `gpt-6-luna` | 
| `gpt-4o-mini-2024-07-18` , the snapshot`gpt-4o-mini` points to | January 14, 2027 | October 14, 2026 | `gpt-6-luna` | 
| `gpt-4.1-2025-04-14` , the snapshot`gpt-4.1` points to | January 14, 2027 | October 14, 2026 | `gpt-6-luna` | 
| `gpt-4.1-mini-2025-04-14` , the snapshot`gpt-4.1-mini` points to | January 14, 2027 | October 14, 2026 | `gpt-6-luna` | 
| `gpt-4o-2024-05-13` | Shut down October 23, 2026 | April 22, 2026 | `gpt-5.6-sol` | 
| `gpt-4.1-nano` ,`gpt-4.1-nano-2025-04-14` | Shut down October 23, 2026 | April 22, 2026 | `gpt-5.6-luna` | 
| `gpt-4o-search-preview-2025-03-11` ,`gpt-4o-mini-search-preview-2025-03-11` | Shut down July 23, 2026 | April 22, 2026 | `gpt-5.6-terra` | 
| `chatgpt-4o-latest` | Shut down February 17, 2026 | November 18, 2025 | `gpt-5.1-chat-latest` | 

The first five rows are the January 14 shutdown. The rest already happened. They matter only if a fallback list or an old config still names them, because those calls already fail.

Ninety-two days is short by OpenAI's own rules. The policy gives generally available models at
least six months unless safety or compliance concerns require a faster timeline, and the
deprecations page gives no reason for this one. The previous GPT-4o and GPT-4.1 shutdown, which
took `gpt-4o-2024-05-13` and `gpt-4.1-nano` on October 23, was announced 184 days ahead.

### The GPT-4o audio, realtime and speech models have their own dates

The `gpt-4o` name is also on OpenAI's audio models, and they shut down on three other dates:

| Shutdown date | Model ID | Listed replacement | 
|---|---|---|
| January 6, 2027 | `gpt-4o-mini-tts` ,`gpt-4o-mini-tts-2025-03-20` ,`gpt-4o-mini-tts-2025-12-15` | `gpt-realtime-2.1-mini` | 
| January 20, 2027 | `gpt-4o-audio` ,`gpt-4o-mini-audio` | `gpt-audio-1.5` | 
| January 20, 2027 | `gpt-4o-realtime` | `gpt-realtime-2.1` | 
| January 20, 2027 | `gpt-4o-mini-realtime` | `gpt-realtime-2.1-mini` | 
| January 20, 2027 | `gpt-4o-mini-transcribe-2025-03-20` | `gpt-4o-mini-transcribe-2025-12-15` | 
| February 26, 2027 | `gpt-4o-transcribe` ,`gpt-4o-mini-transcribe` ,`gpt-4o-mini-transcribe-2025-12-15` ,`gpt-4o-transcribe-diarize` | `gpt-transcribe` or`gpt-live-transcribe` | 

One row is a trap. OpenAI lists `gpt-4o-mini-transcribe-2025-12-15` as the replacement for the
March 2025 transcribe snapshot, and that replacement shuts down on February 26, 2027, five weeks
later. Go straight to `gpt-transcribe` or `gpt-live-transcribe`.

## What happens to the undated gpt-4o and gpt-4.1 names

Most code calls the short name, not the dated snapshot. OpenAI's model pages say where each one
points: `gpt-4o` to `gpt-4o-2024-08-06`, `gpt-4o-mini` to `gpt-4o-mini-2024-07-18`, `gpt-4.1` to
`gpt-4.1-2025-04-14`, and `gpt-4.1-mini` to `gpt-4.1-mini-2025-04-14`. Each of those pages marks
the model as Deprecated, and every snapshot it lists has either shut down already or shuts down on
January 14.

The deprecations page lists each model by name with its dated snapshots. Unlike rows such as
`gpt-5`, it doesn't list the short ID itself, and OpenAI hasn't said whether a call to `gpt-4o`
fails on January 15 or gets pointed somewhere else. Plan for it to fail. If OpenAI
did repoint it, your feature would move to a different model on a date you didn't choose, with no
test run, which is the worse of the two outcomes.

Every response names the snapshot that answered, so you can confirm what a short name resolves to today:

``` python
from openai import OpenAI

client = OpenAI()
resp = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "ping"}],
)
print(resp.model)  # the dated snapshot that served the request, e.g. gpt-4o-2024-08-06
```

## What replaces GPT-4o and GPT-4.1: gpt-6-luna

OpenAI lists one replacement for all four models: `gpt-6-luna`, released on September 22, 2026 and
the lowest-priced model in the GPT-6 family. Its model page calls it "our most efficient model for
focused, high-volume tasks." On paper, at standard prices per million tokens:

|  | `gpt-4o` | `gpt-4o-mini` | `gpt-4.1` | `gpt-4.1-mini` | `gpt-6-luna` | 
|---|---|---|---|---|---|
| Input | $2.50 | $0.15 | $2.00 | $0.40 | $0.10 | 
| Cached input | $1.25 | $0.075 | $0.50 | $0.10 | $0.01 | 
| Output | $10.00 | $0.60 | $8.00 | $1.60 | $0.50 | 
| Context window | 128,000 | 128,000 | 1,047,576 | 1,047,576 | 1,050,000, of which 922,000 input | 
| Max output tokens | 16,384 | 16,384 | 32,768 | 32,768 | 128,000 | 
| Knowledge cutoff | October 1, 2023 | October 1, 2023 | June 1, 2024 | June 1, 2024 | May 18, 2026 | 
| Reasoning | No | No | No | No | Yes, `medium` by default | 
| Fine-tuning | Yes | Yes | Yes | Yes | No | 

Every per-token price goes down. `gpt-6-luna`'s input price is a twenty-fifth of `gpt-4o`'s and
its output price a twentieth. Two things work against that:

- +**Reasoning tokens.** At the default`medium` effort the model reasons before it answers, and
OpenAI bills those reasoning tokens as output. OpenAI's reasoning guide says a request can use
anywhere from a few hundred to tens of thousands of them.
- +**Price rules the old models don't have.**`gpt-6-luna` charges for cache writes ($0.125 per
million tokens for a 30-minute write, 1.25 times its input rate), and a prompt over 272,000 input
tokens is billed at twice the input and cache rates and 1.5 times the output rate for the whole
request. The GPT-4.1 models
have a single rate at every prompt length, so a GPT-4.1 route that used its million-token window
pays the long-context rate on`gpt-6-luna` . A prompt over 922,000 tokens doesn't fit at all.

So the per-request cost depends on the reasoning effort you pick and on your traffic, and step 5 is where you measure it.

Whether `gpt-6-luna` is enough is a question for your own traffic. OpenAI recommends its
lowest-priced GPT-6 model for all four, including GPT-4o, which its model page still calls a
flagship. If it fails your comparison on a `gpt-4o` or `gpt-4.1` route, the next tiers up are
`gpt-6.1-terra` ($1 input, $5 output), which supports `none`, and `gpt-6.1-sol` ($2 input, $10
output), which doesn't. Both need the Responses API for any tool calling.
Avoid migrating onto a model with its own date: `gpt-5` shuts down on December 11, 2026 and
`gpt-5.1` on April 1, 2027.

## Fine-tuned GPT-4o and GPT-4.1 models

A fine-tuned model follows its base model's shutdown date. Every model that starts with
`ft:gpt-4o-2024-08-06`, `ft:gpt-4o-mini-2024-07-18`, `ft:gpt-4.1-2025-04-14` or
`ft:gpt-4.1-mini-2025-04-14` stops serving on January 14, 2027. This is the hardest part of the
migration:

- +`gpt-6-luna` 's model page lists fine-tuning as not supported.
- +OpenAI has been closing self-serve fine-tuning in stages. Since May 7, 2026, organizations that never ran fine-tuning can't start. Since July 2, 2026, organizations that haven't run inference on a fine-tuned model in the past 60 days can't create jobs. From January 6, 2027, active existing customers can't create new jobs either.
- +After January 14 the fine-tune is gone, and with it the only record of how it behaved beyond whatever you logged.

The realistic path is to replace the fine-tune with a prompt: few-shot examples drawn from the
training set, plus Structured Outputs where the fine-tune enforced a format. Then measure the
prompted `gpt-6-luna` against the fine-tune's own outputs on held-out cases while the fine-tune
still answers. OpenAI also says some developers may be able to provision dedicated capacity to keep
using a model after its shutdown date, through its sales team.

Fine-tunes trained on Azure OpenAI last longer. Azure lists the deployment retirement for
fine-tuned `gpt-4o` and `gpt-4o-mini` on October 1, 2027, and for the fine-tuned `gpt-4.1` models
on October 14, 2027.

## Azure OpenAI retires GPT-4o and GPT-4.1 later

Azure OpenAI, documented under Microsoft Foundry, sets its own
[retirement schedule ↗](https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-retirement-schedule):

| Model and version | OpenAI API | Azure OpenAI | Azure's listed replacement | 
|---|---|---|---|
| `gpt-4o` 2024-05-13 | Shut down October 23, 2026 | January 14, 2027 | `gpt-5.1` 2025-11-13 | 
| `gpt-4o` 2024-08-06 and 2024-11-20 | January 14, 2027 | April 14, 2027 | `gpt-5.1` | 
| `gpt-4o-mini` 2024-07-18 | January 14, 2027 | April 14, 2027 | None listed | 
| `gpt-4.1` and`gpt-4.1-mini` 2025-04-14 | January 14, 2027 | April 14, 2027 | None listed | 
| `gpt-4.1-nano` 2025-04-14 | Shut down October 23, 2026 | April 14, 2027 | None listed | 

For `gpt-4o` 2024-05-13, Azure says Global Standard and Data Zone Standard deployments upgrade to
`gpt-5.1` automatically at retirement, and Provisioned deployments don't: they need replacement
deployments before January 14. Regional Standard deployments that Azure already retired stay
retired. `gpt-5.1` itself retires on Azure on July 13, 2027. Azure's page
was last updated on September 23, 2026, three weeks before OpenAI's October 14 notice, so check it
again before you plan around an April date.

## ChatGPT retired GPT-4o in February 2026, the API is a different date

Many "GPT-4o retirement" headlines are about ChatGPT. On January 29, 2026, OpenAI
[announced ↗](https://openai.com/index/retiring-gpt-4o-and-older-models/) that GPT-4o, GPT-4.1,
GPT-4.1 mini and o4-mini would leave ChatGPT on February 13, 2026, and said that in the API there
were "no changes at this time." OpenAI also said that only 0.1% of users were still choosing GPT-4o
each day. Its [help center ↗](https://help.openai.com/en/articles/20001051-retiring-gpt-4o-and-other-chatgpt-models)
confirms the February 13 retirement, with one exception: ChatGPT Business, Enterprise and Edu
customers kept GPT-4o in Custom GPTs until April 3, 2026. The API notice came eight and a half
months after the announcement, on October 14, 2026.

A model leaving a chat app tells you nothing about its API date. For the API, OpenAI's deprecations page is the schedule that counts.

## Step 1: Find every GPT-4o and GPT-4.1 call

Model strings hide in more places than application code: environment files, Terraform, prompt
registries, notebooks, batch jobs, and the eval harness, where a judge model is easy to forget.
Start with a grep, then read every hit (drop `-h` to see the files):

```
grep -rhoE "(ft:)?gpt-4(o|\.1)[a-z0-9.:_-]*" \
  --exclude-dir={node_modules,.git,.venv,dist} . | sort | uniq -c | sort -rn
```

Then ask the API. `GET /v1/models` lists every model your organization can call, fine-tunes
included, and OpenAI documents an optional `shutdown_date` field on each:

``` python
from openai import OpenAI

for m in OpenAI().models.list():
    if m.id.startswith(("gpt-4o", "gpt-4.1", "ft:gpt-4o", "ft:gpt-4.1")):
        print(m.id, getattr(m, "shutdown_date", None))
```

For each ID, note the route that calls it and what the route does with it: tool calls, JSON output, free text or audio. That decides how much testing step 5 needs.

## Step 2: Record a baseline while GPT-4o still answers

Once a model shuts down, nobody can record what it did. Before January 14, or January 6 for
`gpt-4o-mini-tts`, capture 100 to 300 real production inputs per route, stratified by route, with
what production actually did: the tools called, their arguments, the JSON fields, the refusals.
For a fine-tune this recording is the only specification of its behavior that will survive it.

The method is in
[Build a golden dataset for LLM evals from production traffic](https://www.evalshift.dev/blog/build-a-golden-suite-from-production-traffic).

## Step 3: Pick the target model and reasoning effort per route

Start each route on `gpt-6-luna` at reasoning effort `none`, which is the smallest change from a
non-reasoning model. Run the same cases at `low` as well, because the reasoning effort is now a
setting you choose, and it changes both quality and cost. Move a route up to `gpt-6.1-terra` only
if both fail on that route, and through the Responses API if the route calls tools. Write down the reason for each choice, because the next deprecation
will ask the same question.

## Step 4: Update the request for gpt-6-luna

OpenAI's [GPT-6 migration guide ↗](https://developers.openai.com/api/docs/guides/latest-model) lists
the compatibility checks. From a GPT-4o or GPT-4.1 request, these are the ones that bite:

| In your GPT-4o or GPT-4.1 request | On `gpt-6-luna` | What to do | 
|---|---|---|
| No reasoning setting | Reasoning effort defaults to `medium` | Set it explicitly: `reasoning_effort` in Chat Completions,`reasoning.effort` in Responses | 
| `temperature` ,`top_p` ,`top_logprobs` , and`logprobs` in Chat Completions | Must be removed when reasoning effort isn't `none` | Remove them, or keep effort at `none` | 
| `tools` in Chat Completions | Function calling works only with `reasoning_effort: "none"` | Use `none` , or move tool-calling routes to the Responses API | 
| An output cap sized for the visible answer | Reasoning tokens count toward it. In the Responses API, a response that reaches it ends with status `incomplete` , possibly before any visible text | Raise the cap. OpenAI suggests reserving at least 25,000 tokens for reasoning and output when you start | 
| `prompt_cache_retention` | Replaced by `prompt_cache_options.ttl` set to`"30m"` | Switch the parameter, and budget for cache writes | 
| `prediction` (Predicted Outputs) | Not among `gpt-6-luna` 's listed features | Remove it and recheck latency | 

The closest drop-in for a Chat Completions route with tools keeps reasoning off:

```
# Before
resp = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
    temperature=0,
)

# After: reasoning off, so Chat Completions function calling works and temperature is allowed
resp = client.chat.completions.create(
    model="gpt-6-luna",
    messages=messages,
    tools=tools,
    reasoning_effort="none",
    temperature=0,
)
```

That is the smallest change, not necessarily the best one. To try a tool-calling route with reasoning on, move it to the Responses API, where tools work at any effort, and compare both versions in step 5.

## Step 5: Replay real traffic on both models and diff per route

Everything so far makes `gpt-6-luna` answer. This step finds out whether it still does the same
job. The regressions that matter in a model swap mostly read fine: an argument changes format, an
enum field moves one notch, a request the old model refused becomes a tool call.

- +**Assert deterministically first.** Check the tools called, the argument formats and every
structured field. Use an LLM judge only for free text.
- +**Sample each case several times when reasoning is on.** Without`temperature` , one sample can't
tell a regression from sampling noise. Score the share of samples that pass.
- +**Measure cost and latency per request.** The usage object reports reasoning tokens
(`completion_tokens_details.reasoning_tokens` in Chat Completions,`output_tokens_details.reasoning_tokens` in Responses), which is where a cheaper list price can
turn into a bigger bill.
- +**Compare per route, never one average.** A drop on one route disappears in an overall score.

The full walkthrough, with code and the six regressions it caught on a real model upgrade, is in
[How to catch LLM regressions before a model upgrade ships](https://www.evalshift.dev/blog/llm-regression-testing-model-upgrade).

## Step 6: Cut over before January 14, with a rollback path

Switch one route at a time behind a flag, starting with the route the diff cleared most clearly.
Keep the old snapshot as the fallback while it still answers, then take it out of every fallback
list before January 14: a fallback to a shut-down model fails exactly when you need it. Watch error
rates, cost, latency and `response.model` per route for a week after each switch.

`gpt-6-luna` has no shutdown date yet. Put a check for it in CI rather than on a calendar: the
[deprecation schedule post](https://www.evalshift.dev/blog/llm-model-deprecation-schedule) has a short script that fails the
build when a pinned model's `shutdown_date` is less than 90 days away or the model is no longer
listed.

## Doing this with EvalShift

Disclosure: I'm the founder of EvalShift, and steps 2 and 5 are the part it automates. The capture
SDK wraps the OpenAI client and records real runs, including tool calls, and `compare` replays them
against the replacement:

``` python
from openai import OpenAI
from evalshift import capture
from evalshift.adapters.openai import wrap_openai

client = wrap_openai(OpenAI())  # each create() inside a capture records one model call

TOOLS = [...]  # the tools the agent is offered, or [] for none

@capture.agent(suite="support", redact=True, tools=TOOLS)  # no-op unless EVALSHIFT_CAPTURE=1
def handle_ticket(message): ...
pip install evalshift
EVALSHIFT_CAPTURE=1 python my_agent.py   # record production-shaped runs
evalshift capture sync                   # recorded runs -> golden suite
evalshift compare --suite-name support --to gpt-6-luna
```

Both arms are live calls, so run it before January 14. EvalShift's config has no reasoning-effort
setting, so `compare` measures `gpt-6-luna` at OpenAI's default, `medium`: the change you get by
editing only the model string, not the `none` setting from step 3. EvalShift sends
`temperature=0` on every call. If a model rejects it, EvalShift resends without it and marks the
run as non-deterministic in the report, so set `defaults.samples_per_example` above 1 for the
reasoning model. The `max_cost_increase` threshold in the `migration_policy` fails the verdict if
the paired cost rises by more than you allow, which is where reasoning tokens outweighing the lower
price would show up. Docs: [/docs/sdk-adapters](https://www.evalshift.dev/docs/sdk-adapters),
[/docs/captures](https://www.evalshift.dev/docs/captures), [/docs/migration-policy](https://www.evalshift.dev/docs/migration-policy).

## FAQ

**When is GPT-4o being shut down?** On OpenAI's API, the `gpt-4o-2024-08-06` and
`gpt-4o-2024-11-20` snapshots shut down on January 14, 2027, together with `gpt-4o-mini-2024-07-18`.
OpenAI announced it on October 14, 2026. The oldest snapshot, `gpt-4o-2024-05-13`, already shut
down on October 23, 2026, and ChatGPT stopped offering GPT-4o on February 13, 2026.

**Is GPT-4.1 being deprecated?** Yes. `gpt-4.1-2025-04-14` and `gpt-4.1-mini-2025-04-14` shut down
on OpenAI's API on January 14, 2027, and OpenAI's model pages mark `gpt-4.1` and `gpt-4.1-mini` as
deprecated. `gpt-4.1-nano` already shut down on October 23, 2026. On Azure OpenAI the GPT-4.1
models retire on April 14, 2027.

**What replaces GPT-4o and GPT-4o mini?** OpenAI lists `gpt-6-luna` as the replacement for GPT-4o,
GPT-4o mini, GPT-4.1 and GPT-4.1 mini. It is a reasoning model with a lower per-token price than any
of them, it defaults to `medium` reasoning effort, and it supports `none`, which is the closest match
to the old non-reasoning behavior. If it falls short on a route, `gpt-6.1-terra` is the next tier
up, through the Responses API for tool calls.

**Will the gpt-4o model name keep working after January 14, 2027?** OpenAI hasn't said. `gpt-4o`
points to `gpt-4o-2024-08-06`, OpenAI's model page marks it as deprecated, and every snapshot it
lists is shut down or shuts down on January 14. Plan for calls to `gpt-4o`, `gpt-4o-mini`, `gpt-4.1`
and `gpt-4.1-mini` to fail.

**What happens to fine-tuned GPT-4o and GPT-4.1 models?** They shut down with their base model on
January 14, 2027. `gpt-6-luna` can't be fine-tuned, and from January 6, 2027 existing customers can
no longer create new self-serve fine-tuning jobs, so the usual path is to replace the fine-tune with
a few-shot prompt and test it against the fine-tune's outputs before the date.

**Is GPT-4o still available in ChatGPT?** No. OpenAI retired GPT-4o, GPT-4.1, GPT-4.1 mini and
o4-mini from ChatGPT on February 13, 2026, and Business, Enterprise and Edu customers kept GPT-4o
in Custom GPTs only until April 3, 2026. That retirement didn't change the API, where the shutdown
date is January 14, 2027.

**How long can I use GPT-4o on Azure OpenAI?** Azure lists April 14, 2027 for `gpt-4o` versions
2024-08-06 and 2024-11-20, `gpt-4o-mini` and the GPT-4.1 models, and January 14, 2027 for `gpt-4o`
2024-05-13. Fine-tuned deployments last until October 2027.

## Keep reading

- +[LLM model deprecation schedule 2026](https://www.evalshift.dev/blog/llm-model-deprecation-schedule) — every OpenAI,
Anthropic and Google shutdown date side by side, with Azure and Bedrock.
- +[How to catch LLM regressions before a model upgrade ships](https://www.evalshift.dev/blog/llm-regression-testing-model-upgrade) — step 5 in full, with code and the six failures it caught.
- +[What actually breaks when you switch LLMs](https://www.evalshift.dev/blog/what-breaks-when-you-switch-llms) — why the
worst regressions from a model swap read as correct.
- +[Build a golden dataset for LLM evals from production traffic](https://www.evalshift.dev/blog/build-a-golden-suite-from-production-traffic) — capturing the baseline before the old model is gone.
- +[LLM drift](https://www.evalshift.dev/blog/llm-drift) — how a model can change under a name you never edited.
