# Azure model-router previews retire Jan 27: what to pin instead

URL: https://infro.io/blog/azure-model-router-previews-retire-jan-27-what-to-pin-instead
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-11
Last modified: 2026-11-11
Last reviewed: 2026-11-11 (next review due 2026-12-11)
Topic: Routing and reliability
Format: Guide

> Azure lists model-router 2025-05-19 and 2025-08-07 as Preview with a 2027-01-27 retirement date, and preview deployments are force-upgraded or terminated [^azure-schedule][^azure-lifecycle]. Inventory the deployments now, record which models actually answer, and write the routing rule as a named route in your own gateway so a router version never decides your quality or cost.

Key takeaways:
- Azure's retirement schedule lists model-router 2025-05-19 and 2025-08-07 as Preview, retiring 2027-01-27; 2025-11-18 is listed as GA, retiring 2027-05-20.
- Preview deployments are force-upgraded to a newer preview or GA version, or terminated; there is no option to stay on a retiring preview version.
- A router version does not fix behaviour: 2025-11-18 receives new underlying models in place, and a router upgrade changes the pool of models that can answer.
- Inventory deployments and record the model that actually answered each request before the date, so you have a baseline to match.
- Put the routing rule in a named gateway route with explicit targets, and move traffic with a weighted canary rather than waiting for the forced upgrade.

## 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:

1. **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.
2. **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.
3. **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.
4. **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](https://infro.io/blog/model-aliases-vs-pinned-snapshots), with the difference that the swap happens per request, inside one name [4].

> **Warning: Pool changes can also come from underlying retirements**
> The pool page for 2025-11-18 lists models that the schedule shows retiring soon, for example `o4-mini` and `Llama-4-Maverick-17B-128E-Instruct-FP8` on 2026-11-19 and `claude-haiku-4-5` on 2026-11-15 [3][1]. The pages I read do not say when a retired model leaves the pool. Record the answering models weekly rather than assuming the pool you deployed against is the pool you have.

## 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.

```bash
# 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
done
```

For 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].

```python
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].

> **Example: Illustrative rule set (invented names and ids)**
> This shows the shape of a rule in the route body from INFRO's docs [6]; the model ids and thresholds are made up for illustration, and the real id format for your Azure connection is on the Models page of the docs.
> 
> ```json
> [
>   {
>     "name": "Large prompts",
>     "match": "all",
>     "conditions": [{ "field": "input_tokens", "op": "gt", "value": 100000 }],
>     "targets": [{ "connection_id": "conn_azure_1", "model": "<large-context model>" }],
>     "fallthrough": true
>   },
>   {
>     "name": "Tool-calling steps",
>     "match": "all",
>     "conditions": [{ "field": "has_tools", "op": "eq", "value": true }],
>     "targets": [{ "connection_id": "conn_azure_1", "model": "<tool-capable model>" }],
>     "fallthrough": true
>   }
> ]
> ```
> 
> Requests matching neither rule use the route's default targets, for example a mid-size model first and a second model as failover.

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](https://infro.io/blog/is-your-fallback-model-good-enough-test-fallback-equivalence) 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:

1. Keep the router deployment as one target and add the explicit-model targets beside it.
2. 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.
3. Raise the weight in steps. Hold each step for at least a weekday cycle, since traffic varies by day.
4. At 100% on explicit targets, set the router target to weight 0 as a standby, then remove it well before 27 January.
5. Delete the old deployment. Do not leave it as a safety net that Azure may force-upgrade or retire under you.

> **Example: Illustrative cost mix (invented numbers)**
> Suppose a deployment's step 2 table shows requests answered 60% by model A, 30% by model B and 10% by model C, with invented list rates per 1,000 requests of 2, 6 and 25 (any currency). The blended figure is 0.6×2 + 0.3×6 + 0.1×25 = 5.5. If a router change shifted 5 points from A to C, the blend would be 0.55×2 + 0.3×6 + 0.15×25 = 6.65, about a fifth higher, with no error and no code change. Your own numbers come from your own table at your own contracted rates.

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-router` deployment 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.

## Questions

### Does the retirement date apply to model-router 2025-11-18?

No. The schedule lists 2025-11-18 as GA with a retirement date of 2027-05-20, while 2025-05-19 and 2025-08-07 are listed as Preview with 2027-01-27 [1]. The model router page labels the two older versions as frozen [3].

### Can I stay on a retiring preview version?

Not according to Microsoft's lifecycle policy: there is no option to remain on a retiring preview model, and deployments are either upgraded or terminated [2].

## Sources

1. Model retirement schedule — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-retirement-schedule (accessed 2026-11-11)
2. Foundry Models lifecycle and support policy — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-retirements (accessed 2026-11-11)
3. Model router for Microsoft Foundry — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-router (accessed 2026-11-11)
4. Model aliases vs pinned snapshots: avoid silent model swaps — INFRO. https://infro.io/blog/model-aliases-vs-pinned-snapshots (accessed 2026-11-11)
5. Monitor model router in Microsoft Foundry — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/monitor-model-router (accessed 2026-11-11)
6. Routes — INFRO Docs. https://infro.io/docs/routes (accessed 2026-11-11)
7. Traffic changes — INFRO Docs. https://infro.io/docs/observability/traffic-changes (accessed 2026-11-11)
