The Model Your Agent Runs On Has a Shutdown Date

LLM model deprecation gives your agent a hard retirement date, not a temporary outage. Failover does not help when the thing you fall back to is never coming back.

Viral RuparelNo. 91 of 9111 min read

A team I was helping shipped a support agent last spring. It was pinned to one model string, the exact snapshot that passed their evals, hard-coded in three services and a nightly batch job. Then the provider sent an email. That model retires in sixty days. Not an incident, not a slow quarter, a date on a calendar. Their failover logic was useless, because failover assumes the thing you fall back to is the thing coming back. This time it was not coming back. They had two months to qualify a different model, untangle prompts that had quietly grown dependent on the old one, and re-run every eval, or the agent would start returning errors from the API on a Tuesday morning.

Left, an agent hard-pinned to one model string breaks the day the provider retires it; right, a model seam routes to a primary and a validated second source, both kept on parity evals, with a watcher reading the shutdown date.
Figure. Second-source migration: a seam between your agent and a model that can be switched off

An outage ends. A shutdown date does not.

Most reliability work for agents assumes the failure is temporary. The provider has a bad ten minutes, your circuit breaker trips and retries, and the model is back before lunch. That is the right mental model for an outage. It is the wrong one for deprecation.

A deprecated model is not slow or flaky. It is scheduled for removal. The provider tells you the date, and on that date every request to that model fails permanently. No retry budget fixes it. No failover helps, because the usual failover target for a model is a different snapshot of the same model from the same vendor, and when a whole family is being retired at once, that target may be going away on the same day.

This is the trap. The tooling that makes you feel safe against outages gives you nothing against deprecation. You can have perfect retries, a healthy breaker, and shadow traffic, and still wake up to a dead agent because the model under all of it hit its retirement date and you never built a way to swap it. Deprecation is the one production failure you get months of warning about and still manage to be surprised by.

Every provider already publishes the date

The dates are not a secret. They are in the docs, and they are specific.

OpenAI's deprecations page lists every model with a status of Active, Deprecated, or Shutdown, and the exact shutdown date. As of this writing the gpt-5 family, including gpt-5, gpt-5-mini, gpt-5-nano, and gpt-5-pro, is scheduled to shut down on December 11, 2026, with the o3 and o3-pro reasoning models retiring the same day. The policy promises at least six months of notice for generally available models, three months for specialized and image variants, and only about two weeks for anything with "preview" in the name. You can read the retirement date for a model programmatically through the shutdown_date field on the models endpoint.

Anthropic's model deprecations page runs on the same lines, with a status table, a recommended replacement for each retiring model, and a commitment of at least sixty days of notice before a publicly released model retires. It also tells you something useful: claude-sonnet-4-5 was deprecated on September 30, 2026 and retires on November 30, 2026, and the recommended replacement is claude-sonnet-5-5. If your agent still names the older snapshot, that is a live countdown. Anthropic even gives you an audit path, an export on the usage page that breaks spend down by API key and model, so you can find every place a retiring model is still in use.

The lesson is not that providers are careless. It is that the information is pull, not push. There is an email, but it goes to one account owner, not to the on-call engineer and not to your deploy pipeline. If nobody turns that date into a ticket, the date still arrives.

Your reseller keeps a different calendar

It gets harder when you do not call the vendor directly. If you reach models through a cloud marketplace or an IDE, the retirement schedule is theirs, not the model maker's.

Azure's model retirement schedule is a good example. It carries its own dates for OpenAI, Anthropic, Meta, Mistral, and more, and they do not always match the vendor's own page. Some partner models on that marketplace carry a fifteen-day notice rather than sixty, and provisioned deployments are explicitly not auto-upgraded, so you have to create the replacement and move traffic yourself. The same model can have one retirement date on the vendor's API and another on a reseller, which means "we checked the provider docs" is not the same as "we checked where our traffic actually goes."

Then there is the sharper version: commercial revocation. In November 2026, OpenAI ended Cursor's built-in access to its models after SpaceX acquired Cursor, effective November 12 with what OpenAI said was the maximum notice its contract allowed. Users could keep going by bringing their own API key, but anything that assumed the hosted models would just be there had to change. A model can become unavailable to you not because it was retired for everyone, but because the commercial relationship that gave you access ended. From your agent's point of view the two look identical: the model you depended on is no longer callable, and no retry will bring it back.

Build the swap before you need it

The fix is structural and it is cheap if you do it early. Put a thin seam between your agent and the model, so the model identity is configuration, not a constant scattered through the code. This is the same seam that lets you route across providers to cut cost, used for a different reason.

# A thin seam so a model string is config, not a constant buried in callers.
import os

PRIMARY = os.environ["MODEL_PRIMARY"]        # the model you run today
SECOND  = os.environ["MODEL_SECOND_SOURCE"]  # a different vendor, already validated

def complete(client_for, messages, **kw):
    for model in (PRIMARY, SECOND):
        try:
            return client_for(model).create(model=model, input=messages, **kw)
        except ModelRetiredError:   # model_not_found after the shutdown date
            continue                # the primary is gone for good, use the backup
    raise RuntimeError("both primary and second source are unavailable")

The second source should be a different vendor where you can manage it, not another snapshot from the same family. The point of a second source, a term borrowed from hardware supply chains, is that a single vendor cannot halt your line. If both your models come from one provider, a family-wide retirement or a billing dispute takes out both at once.

One honest warning on the prompt. A prompt is not portable by magic. The one that scores well on your primary has usually absorbed that model's quirks, its tool-calling format, its appetite for instructions, its habits around structured output that is almost valid JSON. Keep the prompt free of vendor-specific tricks where you can, and accept that the second source needs its own tuning. That tuning is the work. Doing it now, calmly, is the whole advantage over doing it in a sixty-day panic.

Keep the second source warm

A backup you have never run is not a backup. It is a guess. The way to keep a second source real is to run your eval set against it continuously, the same gate you would run on any model upgrade, so you always know the current gap between primary and backup.

# Run the backup on the same golden set as the primary, on a schedule.
from statistics import mean

def parity(golden, run, judge):
    scores = {"primary": [], "second_source": []}
    for case in golden:
        for name, model in (("primary", PRIMARY), ("second_source", SECOND)):
            scores[name].append(judge(case, run(model, case.input)))
    gap = mean(scores["primary"]) - mean(scores["second_source"])
    # Alert while you have months to close the gap, not when the primary is gone.
    assert gap < 0.05, f"second source is {gap:.0%} behind: tune it before the date"
    return scores

Two things fall out of running this on a schedule. First, you learn the true cost of switching before you are forced to, and if the gap is large you have time to close it with prompt work or a better backup choice. Second, you catch silent drift. The backup you validated in March may quietly regress when the vendor ships a point release, and a parity job notices while a one-time qualification never would. This is also where the economics surface: switching providers resets your prefix cache and changes the cost of every turn, so the backup's bill is part of knowing whether it is really ready.

Watch the calendar so it does not watch you

The last piece is turning the provider's quiet date into a loud signal in your own systems. Do not rely on the email reaching the right person. Poll the shutdown date and raise it yourself.

# Ask the provider when your model dies, instead of waiting for an email.
import datetime as dt

def days_until_shutdown(client, model, page):
    info = client.models.retrieve(model)      # exposes shutdown_date when one is set
    date = getattr(info, "shutdown_date", None)
    if not date:
        return None
    left = (dt.date.fromisoformat(date) - dt.date.today()).days
    if left < 45:
        page(f"model {model} retires in {left} days: open a migration ticket")
    return left

Run this against every model string your fleet actually uses, which you can enumerate from an inventory or from a usage export. For resellers that do not expose a field, scrape the published schedule into the same check. The goal is that a retirement date shows up as a dated ticket with weeks of runway, routed to the team that owns the agent, instead of as a page at 3am when requests start failing. The same discipline applies to borrowed models: MCP servers that used the host's model are losing that arrangement, and a server that assumed it would always be there needs the same kind of watch.

The parts that bite

A few things make this harder than it reads.

The prompt rarely ports cleanly. Expect the second source to need real tuning, especially around tool calls and structured output, and budget for it rather than assuming a config change is enough.

Tokenizers and pricing differ between vendors, so a backup that matches on quality can still blow your cost or latency budget. Measure both in the parity job, not just the eval score.

Notice windows are uneven. Six months for a flagship, sixty days elsewhere, about two weeks for preview models, fifteen days on some marketplaces. The faster a model can vanish, the less of your critical path should sit on it. Preview and research models are fine for experiments and dangerous as foundations.

The backup drifts when you are not looking. A second source validated once and then ignored for a year is back to being a guess. The parity job is not optional maintenance, it is the thing that keeps the backup a backup.

Finally, resellers and contracts add a layer the vendor docs do not cover. Where your traffic actually lands sets the real date, and a commercial change can move faster than any published deprecation. Inventory the path, not just the model.

The takeaway

Deprecation is the strangest production failure because it is the one you are warned about and still get caught by. The warning is a date in a document and an email to one inbox, and the failure is total and permanent. Everything your team built to survive outages, the breakers and retries and failover, does nothing here, because the model is not down, it is gone. The fix is not more runtime resilience. It is a seam that makes the model swappable, a second source from a different vendor kept honest by your eval set, and a watcher that turns the provider's quiet calendar into a ticket with runway on it.

None of this is exotic. It is the supply-chain discipline that every other critical dependency already gets, applied to the model your agent cannot run without. If your agent is pinned to a single model string and you are not sure what its retirement date is, that is worth thirty minutes before it becomes worth a frantic weekend. If you want a second pair of eyes on where your model dependencies actually point and how fast each one could disappear, let's talk. No pitch, just the map.

ShareXLinkedInviralruparel.com/blog/llm-model-deprecation-second-source-migration

Questions this essay answers

01What is LLM model deprecation?

Model deprecation is when a provider announces that a model will stop accepting requests on a set retirement date. The model still works until that date, then the API returns an error for it. Providers publish these dates in advance, usually with at least sixty days of notice for generally available models and much less for preview models. Deprecation is different from an outage: an outage is temporary and the model returns, while a retired model is gone for good and your only option is to move to a different model before the date.

02How is deprecation different from a provider outage?

An outage is a reliability event with an unknown, usually short, duration. Circuit breakers and failover handle it because the model you fall back to is the one that will recover. Deprecation is a scheduled, permanent removal. Failover does not help, because the model you were pinned to never comes back. The fix is a migration you run before the retirement date, not a runtime retry. Treat the two as separate failure modes with separate plans, because the tooling that protects you from one does nothing for the other.

03What is a second-source model and why keep one?

A second-source model is a different model, ideally from a different vendor, that you have already validated on your own eval set and can switch to without a scramble. The term comes from hardware supply chains, where you qualify two suppliers for a critical part so a single vendor cannot halt your line. For agents, a warm second source turns a retirement date from an emergency migration into a configuration change. The cost is running your evals against two models instead of one, which is cheap next to rebuilding under a deadline.

04How much notice do providers give before retiring a model?

It varies by provider and by model tier. OpenAI commits to at least six months for generally available models, three months for specialized variants, and about two weeks for preview models. Anthropic commits to at least sixty days for publicly released models. Resellers set their own schedules: some marketplace models carry a fifteen-day notice. Preview and research models can disappear fastest, so the shorter the notice window a model carries, the less of your critical path should depend on it.

Working on this in production?I help teams make agents like this reliable. Thirty minutes, no pitch.
Viral Ruparel

Generative AI consultant and full-stack architect. Ex-IBM, former Director of Engineering at a YC W20 startup. Writes about what breaks when agents meet reality.