On 14 October 2026, developers working with OpenAI received a message: GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini will be removed from the API on 14 January 2027. Customised, fine-tuned versions of those models will stop on the same date, OpenAI states on its overview of deprecated models. A week earlier, Anthropic released Claude Haiku 5.5. According to the company, that model costs around 75% less to run than its predecessor, Haiku 4.5.
Two announcements in one month, and both ask the same thing of you: that you can switch models. In the first case because you have to, within 3 months. In the second because it pays off. If your organisation runs an AI application on one of those GPT-4 models, the question now is not which model is best. The question is whether switching costs a week of testing, or a new project. In this article you will read why models change so quickly and which 4 choices make sure your application can keep up with that pace.
Why the model under your application keeps changing
Language models are replaced faster than most software you know. In October 2026 alone, new models came out from Anthropic, Google and Mistral, among others. On 13 October, Google made Gemini 4 Argon available to paying users of the Gemini app. On 29 October, Mistral published the weights of Mistral Large 4, so you can also run the model on your own servers.
At the same time, old models are retired. The same OpenAI page already lists more than ten rounds of deprecations in 2026, from speech models to image models. For models that are still in preview, the notice period can be much shorter according to OpenAI, for example 2 weeks.
On top of that, new models are often cheaper for the same work. Stanford's AI Index Report 2025 calculated that the cost of using a model performing at the level of GPT-3.5 fell more than 280-fold between November 2022 and October 2024. The same report shows that open models, which you can run yourself, are closing in on closed models: on some benchmarks the gap shrank from 8% to 1.7% in a single year.
For your organisation this means three things. The model you build on today will probably not exist in the same form a year from now. There will almost certainly be a model that does the same work cheaper or better. And the choice is no longer only between American providers: there are serious open models you can run within the EU or on your own infrastructure.
Step 1: keep the model separate from your application
The most expensive mistake is an application with the model woven through everything. The model name appears in twenty places in the code, the instructions (prompts) are stored with the provider, and the way answers are processed relies on the quirks of that one specific model. Switching then means going through everything.
So build it in a way that makes the model one replaceable component:
- All calls to a model go through one place in your own code. That is where you define which model is used for which task.
- The prompts live in your own code or configuration, under version control, and not only in a provider's environment.
- Your application expects answers in a fixed shape (for example named fields), so that another model can deliver the same.
That storing prompts with the provider is a risk is clear from the same OpenAI page. The feature for storing and reusing prompts on the OpenAI platform stops on 30 November 2026. OpenAI's own advice: move the content of those prompts into your own application code.
Step 2: define what good looks like, with your own test set
A new model scores higher on a benchmark. But does it do your work better? You only know if you measure it on your own tasks. For that you need a test set: a fixed collection of real questions or documents from your own work, each with the answer you expect or the points you assess it on.
Such a test set does not have to be large to be useful. What matters more is that it contains the difficult cases: the question the previous model got wrong, the document with an unusual structure, the customer who emails in English. Also record what weighs heavily. For an application that summarises case files, a missed fact is worse than a stiff sentence.
The principle is the same as with the question matrix we built for Bouwend Nederland: you design your questions once and then ask them again and again, so the results are comparable and verifiable. When choosing a model, you put the same questions to the old and the new model, and compare the answers side by side.
Keep that test set in your own hands. Here too OpenAI offers a lesson: the company's own Evals platform, where developers could keep their tests, has been read-only since 31 October and stops on 30 November 2026. Anyone whose tests were there has to move those too.
Step 3: choose per task, not per provider
Not every task needs the heaviest model. Sorting an email by topic, summarising a document or extracting data from an invoice often works well with a small, fast model. A complex judgement across several sources needs more. The price difference is large. According to Anthropic, Haiku 5.5 costs 0.10 dollars per million input tokens and 0.50 dollars per million output tokens (for requests up to 100,000 tokens), against 2 and 10 dollars for the larger Sonnet 5.5.
If you work with the layer from step 1, you can use a different model per task, and change that per task again. The test set from step 2 tells you where the small model is good enough.
When choosing, also look at where the model runs. According to Mistral, you can host Mistral Large 4 yourself, or use it via Mistral's own API and Microsoft Foundry, among others. For applications with sensitive data, that can make the difference. Check what the provider's terms say about data storage and training on your data, and check it again for every new model.
One warning about fine-tuning, training a model further on your own examples. It can improve quality, but it ties you to exactly that model. OpenAI writes that fine-tuned versions stop on the same date as the base model. If you fine-tune, you have to do it again with every switch.
Step 4: make switching a fixed part of maintenance
Waiting until the provider emails you a shutdown date is starting too late. Make it a routine:
- Keep an overview of every AI application, the model and version it uses, and the shutdown date if known. Providers publish those dates on a fixed page, such as OpenAI's.
- Test one or two new models every quarter on your test set, even when nothing has to change. That way, when a shutdown date comes, you already know what the successor will be.
- Compare on three points: quality on your test set, cost per task and speed. A model that scores 2 points better but costs 3 times as much is not automatically the better choice.
- Have a person review the switch. A sample of real outcomes checked by someone who knows the work catches errors a test set misses.
- Go live with the switch in a controlled way: first for part of the work, then for all of it, with the option to roll back.
That turns a provider's shutdown date into a planned change, not an emergency.
How NewWorks approaches this
At NewWorks we build AI solutions that need to keep working for years, while the models underneath change every year. That is why in the AI Build Sprint we build multi-LLM and multi-platform: you switch models without starting over. We build code-first, so the solution is yours and you can read how it works, and we host in the EU by default. Why that approach determines whether an application survives the pilot phase, you can read in Why your AI pilot never reaches production.
A step you can take this week: list all your AI applications with the model each one uses. For each model, check the provider's page for a shutdown date. If an application runs on GPT-4o or GPT-4.1, you have until 14 January 2027. Want to know how quickly your application can switch? Plan an introductory call.
Curious how this would work for you?
Plan an introduction


