If you have a favorite GitHub Copilot model, now is a good time to stop taking it for granted.
GitHub is retiring several Copilot models on October 19, 2026, including GPT-5.5, GPT-5.4, GPT-5.4 mini, GPT-5 mini, Gemini 3.7 Flash, and Grok 4.5. Each has a newer suggested replacement, so this is not a case of Copilot suddenly losing its AI capabilities. But the change is still worth paying attention to because the model you use can influence how Copilot writes code, reasons through a problem, edits files, and handles longer development tasks.
For someone who uses Copilot occasionally, the transition may be almost invisible.
For a developer who has built a daily workflow around a particular model, it is a different story.
The important thing is not to panic about the retirement. It is to test what comes next before the old behavior disappears.
Key Points
- GitHub will retire six selected Copilot models on October 19, 2026.
- GPT-5.5 and GPT-5.4 are being replaced by GPT-5.6 Sol.
- GPT-5.4 mini and GPT-5 mini are being replaced by GPT-5.6 Luna.
- Gemini 3.7 Flash is being replaced by Gemini 3.8 Flash.
- Grok 4.5 is being replaced by Grok 4.6.
- The retirement covers Copilot Chat, inline edits, ask and agent modes, and code completions.
- Developers do not need to manually remove the retired models.
- Business and Enterprise administrators should check their model policies.
- The best way to prepare is to test replacement models against real development work rather than generic prompts.
The Models Are Changing Faster Than Most Codebases Do
There is something slightly strange about using AI for software development.
Your application might have been running unchanged for months, while the tool helping you maintain it changes underneath you several times.
That is essentially what is happening with Copilot.
GitHub has announced the October 19 retirement as part of its continuing model rotation. The current replacement list is:
| Retiring model | Suggested replacement |
|---|---|
| GPT-5.5 | GPT-5.6 Sol |
| GPT-5.4 | GPT-5.6 Sol |
| GPT-5.4 mini | GPT-5.6 Luna |
| GPT-5 mini | GPT-5.6 Luna |
| Gemini 3.7 Flash | Gemini 3.8 Flash |
| Grok 4.5 | Grok 4.6 |
GitHub says these changes apply across Copilot experiences rather than only the chat interface. That includes inline edits, ask and agent modes, and code completions.
That last part is easy to overlook.
A developer may think, “I barely use Copilot Chat, so this won’t affect me.”
But perhaps Copilot is quietly suggesting the next function, generating tests, or helping modify an existing file every few minutes.
The model can still matter.
October 19 Is Not Really a Migration Deadline
There is an important distinction between a model being retired and a developer needing to perform a migration.
GitHub says no action is required to remove the deprecated models after they are retired. Suggested alternatives are automatically enabled for Copilot Business and Enterprise customers when the default model policy allows them, unless an administrator has disabled the global default or specifically disabled the replacement model.
So you probably will not wake up on October 20 and discover that you needed to run some special migration command.
The more useful deadline is earlier:
Test your workflow before October 19.
That is the part developers control.
If GPT-5.4 has been your preferred model for a particular kind of work, try GPT-5.6 Sol now. If you use GPT-5 mini for quick tasks, see how GPT-5.6 Luna behaves in those same situations.
Do not judge the replacement from one clever prompt.
Give it the kind of work you actually do.
Your Favorite Model May Have Been Doing More Than You Realized
Consider a normal afternoon.
You open a TypeScript project and ask Copilot to explain a function. A few minutes later, you ask it to refactor another function without changing its public API. Then you generate a handful of tests. Later, you ask an agent to investigate why a particular request is failing.
Those are four different jobs.
They may all look like “coding with AI,” but they put different demands on a model.
A useful chat answer is not necessarily evidence that the model will make good multi-file edits.
A strong code completion model is not necessarily the one you would trust to investigate an unfamiliar repository.
And a model that produces beautiful explanations can still make irritating changes when asked to modify existing code.
That is why simply replacing one model name with another is not enough.
The workflow is what needs testing.
One Copilot Setting Does Not Control Everything
This is probably the most useful detail to understand before the retirement date.
Changing the model in Copilot Chat does not automatically change the model used for inline suggestions. GitHub documents these as separate model-selection experiences. The models available to you can also vary according to your Copilot plan and the client you are using.
So if you open Copilot Chat, select a new model, ask three questions and decide that everything feels fine, you have only tested one part of your workflow.
Your inline completions may still behave differently.
That matters because inline suggestions are often where developers develop a strong preference without consciously thinking about it.
You start typing a function.
Copilot predicts the next few lines.
You accept the suggestion.
Then you keep going.
When that happens dozens of times a day, even small differences in relevance or coding style can become noticeable.
Agent Mode Is Where I Would Test First
If you use Copilot agent mode, give the replacement models some real work before the retirement date.
Agent mode is fundamentally different from asking a one-off question. Copilot can work through edits, update the working set, suggest terminal commands and continue iterating as you respond. Each agent prompt also consumes GitHub AI Credits.
That makes agent tasks a better stress test than simple questions.
Take something representative from your own repository.
For example:
Find why this API request is failing, trace the relevant code, propose a fix, update the tests, and explain what changed.
Then watch what happens.
Does the model find the right files?
Does it understand the existing architecture?
Does it touch unrelated code?
Does it invent a new dependency?
Does it notice the existing test conventions?
Does it stop at the right point, or does it keep changing things that were never part of the task?
Those observations tell you considerably more than asking, “Write a React component.”
Don’t Benchmark Copilot With Artificial Questions
There is a temptation whenever an AI model changes to create a little test suite of clever prompts.
That can be useful, but it is not where I would start.
Your own codebase is the better benchmark.
If you mostly build Flutter applications, test Flutter work.
If you maintain a Node.js backend, test the backend.
If you spend your day inside SQL, test SQL.
If your work involves a large TypeScript monorepo, give the model a problem that requires it to understand that structure.
The reason is simple: the model does not work in isolation.
It works alongside your conventions, existing code, dependencies, tests and architectural decisions.
A model can produce excellent code in an empty example and still be a poor collaborator inside a complicated project.
What Should Individual Developers Actually Do?
Probably less than you think.
Start by identifying whether you are currently using one of the retiring models.
Then try its suggested replacement on a few tasks you already know well.
Do not immediately redesign your entire Copilot workflow.
Instead, compare the new model against familiar situations:
- Explain an unfamiliar function.
- Refactor code without changing its public behavior.
- Generate tests for existing code.
- Find the cause of a real bug.
- Modify several related files.
- Review a proposed implementation.
- Complete ordinary code while you type.
You are not trying to prove that the new model is “better.”
You are trying to answer a much more useful question:
Will this model help me do my work without creating extra work for me?
That is the standard that matters.
Teams Have One Extra Problem
Individual developers can experiment quietly.
Engineering teams cannot always afford that luxury.
If your organization uses Copilot Business or Enterprise, administrators have model policies that can affect which models are available to developers. GitHub’s current policy system can automatically make generally available models follow the organization’s default policy, while administrators can also make more specific decisions.
So if you manage Copilot for a team, check the policy before assuming everyone will see the same replacement models.
Then test the workflows that matter to your team.
This does not have to become a six-week AI evaluation project.
Choose a handful of real tasks.
One bug.
One refactor.
One test-generation task.
One multi-file change.
One agent task, if your team uses agents.
Run them against the new model and let developers judge the results.
That gives you something useful without turning model selection into another full-time job.
There Is Another Detail Worth Watching: AI Credits
Model selection is not purely about output quality.
GitHub notes that different models can consume AI credits at different rates based on their token pricing.
That means a replacement can be technically good and still affect how a heavy user consumes their available usage.
This is particularly relevant when teams use agent workflows heavily.
An agent that takes several steps through a repository can consume substantially more AI resources than a short conversational prompt. GitHub explicitly notes that each agent prompt consumes AI Credits.
So when evaluating a replacement, look at two things:
Did it solve the task well?
And:
Did it do so efficiently enough for the way we use Copilot?
Those questions belong together.
What Happens If You Do Nothing?
For most developers, probably nothing dramatic.
GitHub has already provided suggested replacements, and the deprecated models will be removed from the affected Copilot experiences on October 19. No manual removal is required.
Your existing source code will not suddenly stop compiling.
Your repository will not need to be rewritten.
Your programming language will not change.
What changes is the AI sitting beside your editor.
And that is precisely why doing nothing may be fine for one developer and frustrating for another.
If you barely notice which model Copilot is using, the transition may pass without much thought.
If you have spent months learning how to get particularly good results from one model, you may notice the difference immediately.
The Better Way to Think About Copilot Models
This is perhaps the bigger lesson behind the October change.
Developers should become less attached to model names and more attentive to workflows.
The model landscape is moving too quickly for a development process to depend entirely on one permanent choice.
Instead of saying:
“I always use this model.”
It is more useful to know:
“This model works particularly well for the way I debug.”
Or:
“This one gives me better inline completions.”
Or:
“This one is more reliable when I ask it to work across several files.”
That distinction gives you flexibility.
When GitHub retires a model, you are not rebuilding your development process from scratch. You are simply finding the model that best fits each job now.
Your Copilot Checklist Before October 19
You do not need a complicated migration plan.
Just make sure you have answered these questions:
Are you using one of the retiring models?
GPT-5.5, GPT-5.4, GPT-5.4 mini, GPT-5 mini, Gemini 3.7 Flash and Grok 4.5 are scheduled for retirement on October 19.
Have you tried the suggested replacement?
Do this with real code rather than generic examples.
Have you tested inline suggestions separately?
Chat model selection does not automatically control inline suggestions.
Have you tested agent mode?
If agents are part of your workflow, test them independently.
Have you checked your organization’s model policies?
This matters for Business and Enterprise environments.
Have you considered AI credit usage?
Different models can have different credit costs, so performance is only part of the equation.
If all six answers are clear, there is not much else to do.
The Real Deadline Is Earlier Than October 19
Model retirements sound like infrastructure problems, but for most developers they are really workflow problems.
The code does not need to migrate.
Your expectations might.
A replacement model may solve the same problem differently. It may be more concise, more verbose, more cautious, more aggressive with edits, or simply better at some tasks and worse at others.
That is normal.
The mistake would be waiting until the old model disappears and then trying to figure out what changed while you are already in the middle of a project.
Try the replacement now.
Give it real work.
Keep the parts that make you faster.
Change the parts that do not.
And then get back to building.
GitHub is changing the models behind Copilot. Your job is not to memorize every model name. It is to know which AI behavior actually makes you a better developer.