What retires on January 27, and what does not
Azure's retirement schedule lists model-router version 2025-05-19 and version 2025-08-07 as Preview, each with a retirement date of 2027-01-27. Version 2025-11-18 is listed as GA, retiring 2027-05-20 1. The "Replacement" column is empty for all three rows. Today is 11 November 2026, so the preview date is 77 days away.
The lifecycle policy explains what that date means. Preview models launch with a "not sooner than" date and are sometimes extended. When a decision is made, preview deployments are force-upgraded to a newer preview or the GA version, or the model is retired with no replacement. There is no option to remain on a retiring preview model. Notice is at least 30 days 2. The same page says retired models return 410 Gone to inference requests 2.
Two things the pages I read do not settle, so plan for both outcomes:
- Which version a force-upgraded deployment lands on, since the schedule names no replacement.
- Whether your routing mode and model subset carry over.
The model router page describes versions 2025-08-07 and 2025-05-19 as frozen, with a fixed set of models and no new additions. The 2025-11-18 version is "actively maintained", and new underlying models are added to it over time without changing the version identifier 3. The schedule calls the older two "Preview" and the concepts page calls them "Frozen". Treat the schedule's date as the operative one, and re-read it before you commit to a cutover plan.
What a provider-side router version actually controls
A model router deployment is one deployment name in front of many models. Microsoft describes it as a trained model that analyzes each prompt for complexity, reasoning and task type and routes to an underlying model 3. Your application never names the model. That is the convenience, and it is also the exposure. Four things are decided by Azure rather than by you:
- The pool. Version 2025-11-18 lists models from OpenAI, Anthropic, xAI, Fireworks, DeepSeek and Meta. The pool grows in place, and the version string stays the same 3. Pinning to "2025-11-18" therefore does not pin the set of models that can answer.
- The selection rule. In Balanced mode (the default) the router considers models within a small quality range of the best model for that prompt, for example 1% to 2%, and picks the most cost-effective. Cost mode uses a wider band, for example 5% to 6%. Quality mode picks the highest-rated model and ignores cost 3. These are Microsoft's examples of the band, not a guarantee.
- Controls. Routing mode and model subset are described as options of the latest version 3. A deployment that moves off a frozen version moves onto whatever controls the new version has.
- Limits. The effective context window is that of the smallest underlying model, so a large prompt only succeeds if it happens to be routed to a model that accepts it 3. Cache hits also depend on which model answered consecutive requests 3.
Put together: when the router version or pool changes, the distribution of answering models changes, and so do answer style, output length, latency, cache hit rate and the cost per request. None of that raises an error. It is the same silent-swap pattern covered in Model aliases vs pinned snapshots, with the difference that the swap happens per request, inside one name 4.
Step 1: find every deployment on the retiring versions
Deployments live on Azure resources across subscriptions, so enumerate rather than ask teams. Microsoft's Models API reports lifecycleStatus and per-SKU deprecationDate for a model in a region 2, which tells you the status of the model. It does not list your deployments. For that, list deployments on each Foundry or Azure OpenAI resource and filter on the model name and version.
# Sketch: verify the --query paths against your CLI output before relying on it.
for sub in $(az account list --query "[].id" -o tsv); do
az account set --subscription "$sub"
for acct in $(az cognitiveservices account list \
--query "[?kind=='OpenAI' || kind=='AIServices'].[name,resourceGroup]" -o tsv | tr '\t' ':'); do
name=${acct%%:*}; rg=${acct##*:}
az cognitiveservices account deployment list -g "$rg" -n "$name" \
--query "[?properties.model.name=='model-router'].{sub:'$sub',account:'$name',deployment:name,version:properties.model.version,upgrade:properties.versionUpgradeOption}" \
-o tsv
done
doneFor each hit, write down the deployment name, the resource, the version, whether Auto-update is on, and the deployment type. The model router page says that with Auto-update selected, the deployment updates automatically when new versions become available, and that the set of underlying models then changes, which could affect performance and cost 3. A deployment with Auto-update on is a deployment where Azure has already decided.
Then find who calls each deployment. An inventory of deployments is not an inventory of callers. Match deployment names against your application config, infrastructure code and the request logs of whatever sits in front of Azure. Anything that calls the deployment name directly from application code needs a code change or a gateway in the middle; that is the point of step 3.
Step 2: record what the router actually does for you today
Before you replace a router, you need to know the behavior you are replacing. Azure returns the underlying model in the response's model field. A preview feature header adds model_selection_details, which holds the routing mode and an ordered list of attempts, including failed ones, so you can see fallback. The same envelope can carry session affinity decisions. Microsoft marks all of the metadata as optional during preview and says to parse it defensively 5.
import json, logging
from openai import AzureOpenAI
client = AzureOpenAI(
azure_endpoint=ENDPOINT, api_key=KEY, api_version="2024-10-21",
default_headers={"Foundry-Features": "ModelRouterControls=V1Preview"},
)
resp = client.chat.completions.create(model=DEPLOYMENT, messages=messages)
details = (getattr(resp, "model_selection_details", None) or {}).get("model_router_details", {})
logging.info(json.dumps({
"deployment": DEPLOYMENT,
"served_model": resp.model, # underlying model that answered
"mode": details.get("mode"),
"attempts": [a.get("model") for t in details.get("routing_trace", []) for a in t.get("attempts", [])],
"completion_tokens": resp.usage.completion_tokens,
}))Run this for one to two weeks of representative traffic, or read the same fields from your gateway's request log. The target output is a table per deployment: share of requests by answering model, median and p95 output tokens, p95 latency and estimated cost per request. That table is your acceptance baseline. If the same workload carries an end_user_id, feature or step label, split it by those too, because the router's choices differ by task.
Step 3: put the routing rule in your own gateway
The aim is that a version retirement at Azure changes nothing you did not choose. You do this by moving the decision from a model-picking deployment to a named route your application calls, with explicit targets.
A route in INFRO is a name your application sends as model, resolving to an ordered or weighted list of your own provider connections and the model each should serve. Vendor and model live in configuration instead of in code 6. Your Azure account stays your own connection and Azure keeps billing you directly; the gateway chooses the target.
The router's decision has to be replaced by something you can read. Rules on a route send matching requests to their own targets. The conditions available include request metadata, feature, workflow and step, end user, whether the request streams, carries images or declares tools, the prompt size estimate, and the hour of the day. Rules are checked in order, the first match decides, and a request that matches none uses the default targets 6. A route can also have a prompt classifier pick a class per prompt, with rules sending each class to its own targets 6.
Derive the rules from the step 2 table rather than from guesswork. If the router sent 90% of a feature's requests to two models, those two become that feature's targets. If a long tail went to an expensive model on hard prompts, that is a class or a prompt-size rule, or a separate route for the hard path.
Be clear about what you give up. Azure's router judges each prompt with a trained model. Static rules on size, tools and metadata are coarser, so some easy prompts will go to a stronger model than needed and some hard ones to a weaker one. A classifier on the route narrows that gap, but it is a decision model you have to evaluate yourself. Also check each target against your boundaries: the router "honors data zone boundaries" and routes only to models eligible for your access and deployment types 3, and your explicit targets must meet the same constraints.
Failover also becomes explicit. Azure's router fails over to the next most appropriate model, and a custom model subset doubles as the fallback set 3. In a route, listed targets are tried in order, and a weighted route still falls through to the remaining targets if the first pick fails 6. Test that each fallback is equivalent for your task; is your fallback model good enough covers the method.
Step 4: move traffic with a canary, then retire the deployment
A weighted route picks the first target at random in proportion to weight, and a weight of 0 is a standby that never takes a first attempt 6. That gives a clean migration:
- Keep the router deployment as one target and add the explicit-model targets beside it.
- Start the explicit targets at a small weight and compare against the step 2 baseline: output tokens, latency, error mix, estimated cost per request and your own evaluation score.
- Raise the weight in steps. Hold each step for at least a weekday cycle, since traffic varies by day.
- At 100% on explicit targets, set the router target to weight 0 as a standby, then remove it well before 27 January.
- Delete the old deployment. Do not leave it as a safety net that Azure may force-upgrade or retire under you.
During the canary, watch for silent changes on the gateway side too. INFRO's traffic changes findings read request metadata, never prompts or answers, and fire on events such as a model answered by an id the provider had not reported in the previous 14 days, output tokens per request up by at least 15%, a fall in cached share, more fallback serving, and p95 latency up 7. Each finding gives an estimated weekly change in provider cost, and the per-model signal needs 7 days of reported ids on a connection before an id can count as new 7. These findings tell you that something changed; they cannot tell you that answers got worse, so keep a small evaluation set running alongside. Per-request model, latency, token counts and estimated cost are in the usage records, queryable by project and key, which is where the before-and-after table comes from.
Checklist before January 27
- Every
model-routerdeployment across all subscriptions is listed, with version, Auto-update setting and deployment type. - Every caller of each deployment is identified, including scheduled jobs.
- One to two weeks of answering-model share, output tokens, latency and estimated cost per request are recorded as the baseline.
- Each workload has a named route with explicit targets, rules derived from the baseline, and failover targets that passed an equivalence test.
- Targets meet your data-zone and region requirements.
- Traffic has moved by weighted canary, and the router target is at weight 0 or removed.
- The schedule has been re-read the week of the cutover, since dates can be extended or changed 2.
- The register of pinned model ids carries each model's retirement date, because explicit targets retire too 1.
The last item matters. Moving from a router to explicit models does not end retirements. It makes each one a dated, reviewed change you schedule, instead of a pool change you find out about from a cost report.
