Unlike most software libraries, hosted AI models don’t live forever. Providers retire older models as newer, more efficient ones arrive, freeing up hardware and reducing the number of systems they must maintain. If your product depends on a specific model, its retirement is a predictable event you should plan for.

The lifecycle of a hosted model

  1. Preview/experimental: early access, may change without notice.
  2. Generally available: stable, documented, supported.
  3. Legacy: still available, but newer models are recommended.
  4. Deprecated: a retirement date has been announced.
  5. Retired: requests to the model fail or are redirected.

Providers publish deprecation pages listing affected models, retirement dates and recommended replacements, and usually notify API customers by email.

Why providers retire models

  • Compute costs: serving many model versions requires dedicated capacity.
  • Better replacements: newer models are often both more capable and cheaper.
  • Safety and maintenance: older models may lack improvements in safety and reliability.

What can break

Switching models is rarely just changing a name in your code.

  • Output style and length differ, which can break parsers expecting a format.
  • Prompt behavior changes: instructions tuned for one model may work worse on another.
  • Function calling and structured output may follow schemas differently.
  • Costs and rate limits change.
  • Fine-tuned models built on a retired base model may need to be retrained.
  • Quality on your specific tasks can go up or down, even if the new model is better on average.

A migration checklist

  1. Inventory: list every place you use each model ID — code, configuration, scripts, third-party tools.
  2. Read the recommended replacement in the provider’s deprecation notice.
  3. Run your evaluation set on the old and new models side by side.
  4. Adjust prompts and parsers where results differ.
  5. Roll out gradually: send a small share of traffic to the new model first and monitor errors, costs and user feedback.
  6. Complete before the deadline, with buffer for surprises.

Reduce future pain

  • Centralize model configuration so changing a model is one setting, not a code search.
  • Keep an evaluation set that you can run in minutes.
  • Avoid over-fitting prompts to quirks of one model.
  • Use structured outputs with validation, so format changes fail loudly instead of silently.
  • Track deprecation feeds as part of your release-watch process.

For non-developers

Consumer assistants also swap underlying models, often without asking. If a workflow suddenly behaves differently, a model change is a likely cause. Saved prompts and custom assistants may need adjusting after major updates.

Common mistakes to avoid

  • Hard-coding model names across the codebase. A model ID scattered in dozens of files turns a simple migration into a search-and-replace exercise with missed spots.
  • Assuming the replacement is a drop-in. Even when providers recommend a successor, outputs, formats and costs can change. Always test.
  • Migrating in the final week. Unexpected prompt or parsing issues take time to fix. Start as soon as the deprecation is announced.
  • Forgetting third-party tools. Plugins, automation platforms and internal scripts may call the retired model too. Include them in your inventory.
  • Losing fine-tuning data. If you fine-tuned a model, keep the training data and configuration so you can retrain on a new base model.

Key takeaways

  • Hosted AI models go through preview, general availability, legacy, deprecation and retirement.
  • Providers publish deprecation dates and recommended replacements on dedicated pages.
  • Migrations can change output formats, prompt behavior, costs and task quality.
  • Inventory model usage, test with an evaluation set and roll out gradually before the deadline.
  • Centralized model configuration and validated structured outputs make future migrations easier.

Frequently asked questions

How much notice do providers give?

It varies by provider and model, from a few months to longer for widely used models. Always check the provider’s deprecation page rather than assuming a fixed period.

What happens if I miss the deadline?

Requests to a retired model typically fail with an error, or in some cases are routed to a replacement. Either way, your application’s behavior changes without testing.

Do open-weight models get deprecated?

Not in the same way. If you host the model yourself, it runs as long as you keep it. But hosted versions on third-party platforms can still be retired.

Can I keep using an old model for compliance reasons?

With hosted APIs, generally not after retirement, unless you have a specific agreement. If you need long-term stability, consider self-hosting an open-weight model.