Old Models Leave on Schedule, New Policy Is Programmable: GitHub Copilot's Two October 19 Changes, Explained Together

On October 19, 2026, GitHub did two things on the same day that look like opposites: it retired six Copilot models, and it took the REST API for managing model availability to general availability (GA). The retirement list is Gemini 3.7 Flash, GPT-5.5, GPT-5.4, GPT-5.4 mini, GPT-5 mini, and Grok 4.5, across most Copilot experiences including Copilot Chat, inline edits, ask and agent modes, and code completions; the replacement list was given at the same time: Gemini 3.8 Flash, GPT-6.1 Sol, GPT-6 Luna, and Grok 4.7. The model-policy API, GA the same day, gives administrators four sets of GET / PATCH endpoints, for enterprises, enterprise teams, agent apps, and organizations. Read together, the message is clear: models coming and going is routine; the genuinely new capability is that "who decides which models a team may use" can finally be written as code and put under audit.

This piece first pins the facts to the two GitHub Changelog originals, then gives separate checklists for individual developers and enterprise administrators, and flags three common misreadings: retirement does not delete your code and conversations; replacement models are enabled by default only if administrators have not switched off the global default; and a second retirement batch waits on November 16 — including Claude Opus models — listed at the end, with the caveat that the second batch's details come from third-party summaries of the changelog and should be checked against GitHub's official pages before acting.

What actually happened on October 19

The first changelog's title is the date itself: "GitHub Copilot models deprecated on October 19, 2026." Its first sentence sets the scope: as of that day, the listed models are deprecated across most GitHub Copilot experiences; its second sentence gives the timeline: the deprecations had been announced on September 18, 2026. In other words, October 19 was not a "sudden notice" but the arrival of a deadline announced a month earlier. That gap is itself a lesson for teams: Copilot model changes come with a notice period, and only people who missed the notice experience the deadline as sudden.

The retirement-to-replacement mapping is worth copying in full, because it is the checklist to grep against. Gemini 3.7 Flash → Gemini 3.8 Flash; GPT-5.5 → GPT-6.1 Sol; GPT-5.4 → GPT-6.1 Sol; GPT-5.4 mini → GPT-6 Luna; GPT-5 mini → GPT-6 Luna; Grok 4.5 → Grok 4.7. Two details matter. First, GPT-5.4 and GPT-5.5 share one replacement, Sol, and both minis share Luna — so after migration a team's model variety converges, and so do the variance in cost and behavior. Second, Grok's replacement is 4.7, not the 4.6 in the earlier notice, which shows that even an official notice's replacement list can change before the deadline; migrate against the October 19 changelog itself, not from memory of the September version.

The changelog also says two reassuring things, each with a boundary. First: "No action is required to remove the deprecated models." That means GitHub removes the old models itself; you do not "uninstall" them — but it emphatically does not mean "your workflows need no action." On the contrary, the very next instruction is "Please update your workflows and integrations to use supported models." Second, for administrators: Copilot Enterprise administrators may need to enable access to alternative models through their model policies in Copilot settings, after which the models appear in the Copilot Chat model selector in VS Code and on github.com. Migration therefore has two halves: GitHub removing old models (automatic), and your organization allowing new ones (manual or policy-driven). Assume only the first half, and the second half will arrive on Monday morning as a ticket saying "the model is gone."

The model-policy API, GA the same day: what four endpoints mean

The second changelog, titled "Copilot model policy API for enterprise, orgs, and teams," was published on October 19, 2026, at 14:32 Pacific time. It announces that the REST API for retrieving and updating Copilot model policies is generally available, with GET and PATCH endpoints at four levels — enterprise (/enterprises/{enterprise}/copilot/model-policies), enterprise teams (/enterprises/{enterprise}/teams/{team_slug}/copilot/model-policies), agent apps (/enterprises/{enterprise}/copilot/apps/model-policies), and organization (/orgs/{org}/copilot/model-policies). Enterprise policies can delegate model control to organizations in organization mode, or to teams and apps in enterprise teams mode.

Why do four levels matter? Because real model governance is never one-size-fits-all. Headquarters may want the whole company defaulted to a few models; one team may need a stricter list for compliance reasons; one agent app (say, an automated review bot) may need its own model set. In the past these could only be maintained by clicking through each organization's settings page, and drift was almost inevitable — someone enabled an extra model in one organization and nobody knew. Now that policy is a resource you can GET, drift can be audited by script on a schedule; now that it can be PATCHed, tightening can be pushed out in one shot instead of page by page.

But the API's GA does not equal governance done automatically. It gives you the ability to "read" and "write," not the answer to "what to write." Which models belong on the allowlist, who may PATCH, whether changes need approval and an audit trail — those remain the organization's own decisions. The pragmatic order is: first GET the full current state and archive it, then diff "the set of models actually in use" against "the supported set after October 19," and only then write the PATCH. Reverse the order — PATCH first, audit later — and you can easily switch off a legitimate model some team is actively using.

Checklist for individual developers: five minutes of work

If you are an individual subscriber, things are simpler, but two actions are still worth doing. First, grep your own configuration: IDE settings, agent configs, CI scripts, AGENTS.md files or prompt templates in repositories — wherever one of the six old model names appears, replace it with the corresponding replacement. An old name does not "auto-upgrade" to a new name; the model it points to is gone, and continuing to reference it yields either an unavailable result or a silent substitution — and silent substitution is one of the hardest failures to debug.

Second, open the model selector and confirm the replacement model is actually visible. If it is not, do not doubt your subscription first; check two things: whether the model is included in your plan, and whether an administrator (if you are in an organization) has allowed it in the model policy. GitHub's wording is explicit: once enabled by policy, the model appears in the selector. Individual users do not have this layer, but for organization users almost every "model disappeared" problem sits exactly here.

Third, do not let "no action required" talk you out of verification. Pick your most familiar task — a completion you know well, or one agent change — run it on the replacement model, and compare behavior against past results. Sol and Luna have different positionings (one general-purpose, one lightweight); moving from a mini to Luna is not necessarily an equivalent swap, and moving from 5.4 to 6.1 Sol may behave differently on long tasks. The end of a migration is not "the name changed" but "the key task still passes on the new model."

Checklist for enterprise administrators: work from the delegation topology

For administrators, October 19's real homework is two tables. The first is a "reference table": across the whole enterprise, which repositories, CI lanes, agent harnesses, and shared prompts reference old model names. The grep must cover code, workflow files, and documentation, because model names often hide in documentation examples — and documentation examples get copied verbatim by newcomers. The second is a "policy table": use the model-policy API's GET endpoints to pull the current state at all four levels — enterprise, team, app, organization — and confirm the status of the replacement models at each level.

Then decide according to the delegation topology. GitHub's rule: enterprise policies can delegate control to organizations in organization mode, or to teams and apps in enterprise teams mode. That means "PATCH once at the enterprise level" does not necessarily equal "effective company-wide" — if your enterprise is in organization mode, the organization-level policy may be the one that actually governs. Confirm your enterprise's mode before writing a PATCH, or you will meet the confusion of "the PATCH succeeded, but developers still cannot see it." The method for confirming the mode is in GitHub's documentation on managing model availability in your enterprise; this article does not repeat the steps, only the emphasis: confirm topology first, then PATCH.

One more default to check: the global default. Under default enablement, replacement models are usually enabled automatically; but if an administrator previously switched off the global default or explicitly disabled a model, the replacement will not appear automatically and must be allowed manually. This "default" is the most common pitfall around October 19: teams assumed migration was automatic, when their own organization had long since switched the automatic channel off. Put the global default's status on the migration checklist, on the first line.

Three common misreadings

First, retirement affects "new requests," not "existing output." The changelog does not say already-generated code or existing conversations will be altered; the conventional reading is that retirement means the old model name no longer serves new requests, not that history is retroactively rewritten. Still, phrase this carefully: the official text makes no explicit promise about how historical conversation records are retained, so important conversation records should be exported and archived by you rather than assumed to be kept by the platform forever.

Second, a replacement model's billing and performance are not a straight translation of the old model's. Third-party summaries of the same changelog note that replacement models bill at their own rates, so usage should be re-checked after switching. The changelog itself gives no price table, and this article cites no unverified rate figures. The first billing cycle after migration deserves a separate look: when the usage mix changes, the cost mix necessarily follows.

Third, October 19 is not the end. According to third-party summaries of GitHub's changelog, another batch retires on November 16, 2026: Claude Opus 4.8, Claude Opus 5, and GPT-5.6 Terra, with replacements Claude Opus 5.5, GPT-6.1 Sol, or GPT-6 Luna; individual subscribers on annual plans keep Opus 4.8 as an exception. This batch differs from October 19's: it touches Claude models, and the Opus line is the default choice for many heavy tasks. Putting November 16 on the calendar and grepping Opus references in advance is the most practical follow-up to this article. But note: this article has not verified each detail of the second batch against the official original, so check GitHub's official changelog before acting.

Judgment: model governance is shifting from "picking models" to "managing policy"

Place the two October 19 changelogs side by side and the trend is obvious. Over the past year, most Copilot news was "another model arrived"; on this day, the news became "old models retire on schedule" and "model policy can be managed programmatically." That shows Copilot's competitive focus shifting from model count to governance capability: what enterprise buyers care about is not how many names are in the selector, but whether they can prove "the whole company only used approved models" and complete a full audit within an hour of a retirement.

For solo developers on vibe projects, the trend carries the same lesson. Even with one repository and one person, it is worth building one habit: model names live in exactly one configuration file, not scattered across ten prompts and scripts; every model change is handled like a dependency upgrade — grep, replace, verify, record. The six names retired on October 19 might have been "new models" a year ago; today they are old names to grep for. The shortening model cycle is exactly why vibe projects must treat "the model" as a variable dependency to manage.

Finally, a closing action you can copy directly: do three things today — grep the six old names, GET your organization's model policy once, and put November 16 on the calendar. Once those three are done, the October 19 news is no longer information for you; it is a checklist item already closed.

How this differs from what the site has already published

On October 26 the site published news about GPT-6.1 Terra arriving in Copilot — a story about "a new model has arrived." This piece covers the other side of the same ecosystem: "old models leave on schedule," plus the model-policy API that went GA alongside. The two complement but do not overlap: the earlier piece is about which new model to pick; this one is about how old references migrate and how policy is managed programmatically. A separate October 15 piece about Copilot and a Logitech key covers an ambient-interface entry point, with no intersection with model retirement.