
Most enterprise conversations about artificial intelligence still start with a comparison. Which model is best at summarising contracts, classifying support tickets or drafting customer replies? The comparison is worth making, but it is no longer the hardest part of the job. The harder problem arrives after the choice is made: the model a workflow depends on will change, and eventually it will be withdrawn.
Foundation-model providers cycle through versions at a pace few enterprise software categories have demanded before. Models are updated quietly, renamed, superseded or retired. When that happens, the applications built on them do not simply keep working: behaviour can shift, outputs can drift, prompts can stop performing as expected, and a migration nobody planned becomes an emergency.
For the Global Tech Awards, which recognises engineering across the technology sector, the topic sits where machine-learning engineering, platform operations, risk management and procurement meet. Model deprecation is not an administrative vendor issue. It is a lifecycle discipline, and the organisations that treat it as one are the ones likely to keep their systems trustworthy as the underlying models move beneath them.
Software teams learned long ago that a library version is a dependency. It is recorded, pinned, tested and upgraded deliberately. Foundation models deserve the same treatment, yet many enterprise deployments still treat a model name in a configuration file as a stable fact.
It is not. Everything that shapes a model's output can change between versions: the weights, the tokenizer, the safety filters, the default parameters and the surrounding application programming interface. A provider may adjust how a system handles long inputs or which parameters are accepted at all. Two versions that share a name can behave differently on the same input.
The practical response is a model registry. Each workflow should record exactly which model version it uses, alongside the parameters, prompt templates, retrieval configuration and any fine-tuning artefacts that contribute to its behaviour. If a team cannot say which model version produced a given output last quarter, it does not have a registry, it has a guess.
Pinning matters, but pinning is not permanence. Holding a workflow to a specific version buys time and stability. It does not prevent the provider from retiring that version eventually, and it does not protect against silent changes within a version where a provider allows them. Pinning is a control, not a guarantee, and it needs a review date.
Evaluation is often treated as a one-off check at selection, which made sense when the model was a fixed artefact. It makes little sense when the model is a service that changes underneath the application.
Evaluation needs to become a standing capability rather than a launch gate. A regression suite should run against representative tasks drawn from the work the system actually does, with expected outcomes recorded and results retained. When a new version is announced, the suite runs against it before migration, and again after. The comparison is the evidence that the change was understood rather than hoped for.
Version-aware evaluation also means testing the edges. A summarisation workflow should be checked on the long, messy documents that appear in practice, not only tidy examples. A classification system should be tested where errors carry consequences. Where retrieval is involved, evaluation should separate the quality of the retrieved context from the quality of the generation.
Retaining those results matters as much as producing them. In regulated settings, and wherever a decision may later be questioned, the ability to show what was tested, when and against which version is part of the audit trail. An evaluation that lives only in a dashboard nobody exported is not evidence.
The organisations that handle deprecation best are rarely the ones that predicted it. They are the ones that made it survivable. That usually means an abstraction layer between the application and the model provider, so that a workflow calls an internal interface rather than a vendor endpoint directly.
Such a layer does more than ease substitution. It provides a place to centralise routing, logging, rate limiting and cost controls, and it allows a secondary model to be configured and tested in advance, so that failover is a rehearsed procedure rather than an improvisation during an outage or a retirement notice.
Fallback is not free. A secondary model will behave differently, and a fallback path that has never been exercised is a hypothesis rather than a control. The useful discipline is to run a proportion of traffic, or a scheduled test workload, through the alternative and compare results.
Abstraction also reduces lock-in: when switching costs are visible and tested, a vendor's lifecycle terms carry more weight.
Contracts for AI services are often negotiated around price, performance and data handling, but lifecycle terms belong alongside them.
Buyers can reasonably ask for defined notice periods before a model is retired, published deprecation schedules, and clarity about how much warning will be given for material behaviour changes. They can ask whether evaluation access is provided, so their own test suites can run against a new version before it becomes the default, and how long inputs and outputs are retained and whether data can be exported.
These are not adversarial requests. They are the questions a serious buyer would ask about any long-lived dependency in a critical system. The AI market is young, the terms are still forming, and buyers who do not ask may find the default position less protective than they assumed.
Procurement also has a role in internal governance. If lifecycle terms are written into contracts, they create an obligation to track versions and review migrations. That obligation gives engineering teams the mandate and the budget to maintain the registry, the evaluation suite and the fallback paths that make the terms meaningful.
For high-stakes and regulated uses, the question after a model change is often simple and difficult: can a past decision be reproduced or explained? Answering it requires more than storing the output.
Logs should capture the model version, the prompt as sent, the parameters in force and, where retrieval is involved, the context supplied. Without those elements, an auditor can see what the system said but not why, and cannot distinguish a change in the model from a change in the input.
Context logging raises its own questions. Prompts and retrieved documents may contain personal or confidential information, so retention periods, access controls and redaction need to be designed rather than bolted on. The record should be sufficient to reconstruct a decision, held only as long as the obligation requires.
Model deprecation will not stop. Providers will keep releasing, revising and retiring models, and enterprises will keep building on them. The difference between an organisation that copes and one that struggles is rarely foresight about which model will disappear. It is the ordinary discipline of treating model versions as managed dependencies, testing changes before they arrive, keeping a tested path to an alternative, negotiating lifecycle terms and preserving the context needed to explain what happened.