What GitHub is retiring on December 14

Developer workstation showing AI model migration, software release stages, and engineering policy checks.

GitHub’s November 13 announcement schedules six models for deprecation across all GitHub Copilot experiences on December 14, 2026: Claude Fable 5, Claude Haiku 4.5, Gemini 3.8 Flash, Gemini 4 Argon, Grok 4.6 and Kimi K3. The scope is wider than the model selector in Copilot Chat. GitHub explicitly includes Copilot Chat, inline edits, ask mode, agent mode and code completions, so the same retirement date can affect how developers ask questions, change code in place, delegate repository work and receive suggestions while editing. (GitHub Changelog)

The notice provides a suggested alternative for each entry, but it does not describe the change as a universal one-to-one replacement that every account will experience identically. Claude Fable 5 is scheduled to move to Claude Fable 5.2. Claude Haiku 4.5 is listed with Claude Haiku 5.5. Gemini 3.8 Flash is paired with Gemini 4 Hydrogen, and Gemini 4 Argon with Gemini 4 Carbon. Grok 4.6 is paired with Grok 4.7. For Kimi K3, GitHub’s table says the alternative is “To be announced,” so organizations using that model do not yet have a named successor in the announcement to validate.

That last detail is operationally important. A team can begin testing the named alternatives immediately, but it cannot treat the Kimi K3 entry as a completed mapping. The destination remains unspecified in the retirement notice, which leaves a separate decision point for any workflow that depends on Kimi K3 being selected or available. GitHub’s supported-model documentation also cautions that model availability depends on the Copilot plan and the place where Copilot is used, such as GitHub.com or an integrated development environment. It says availability can change as models are replaced or updated, so a model appearing in one client or account is not, by itself, proof that it is available everywhere the team works. (GitHub Docs)

Claude Haiku 4.5 has a specific exception in the announcement. It will remain available to individual GitHub Copilot subscribers on annual plans, and GitHub says the deprecation does not apply to those customers. That qualification should be read narrowly: it identifies a class of individual subscribers, not a blanket exemption for every organization or every account that happens to use an annual billing arrangement. For other users, Claude Haiku 4.5 remains one of the models scheduled for deprecation on December 14, with Claude Haiku 5.5 named as the suggested alternative.

GitHub’s notice also describes how suggested alternatives are handled for Copilot Enterprise and Copilot Business customers under default model enablement. The alternatives are automatically enabled when the relevant default is active, unless an administrator has turned off the global default or explicitly disabled the model. If an organization has turned off that global default, an administrator can enable access to the alternatives through model policies in Copilot settings. Once enabled, users see the model in the Copilot Chat model selector in supported Copilot experiences. GitHub says no action is required to remove the retiring models after they have been deprecated, but that does not remove the need to update workflows and integrations before the date.

This distinction—automatic enablement under one policy configuration versus explicit administrator action under another—is why the December 14 deadline should be treated as a configuration and release-management checkpoint. The model names may be visible in different places: in a user’s selection, in organization or enterprise model policies, or in an integration that assumes a particular supported model. A user who only checks the chat interface could miss a policy setting or workflow dependency; an administrator who only enables the suggested alternatives could miss the need to compare how those alternatives behave on the team’s actual tasks.

The immediate inventory is therefore concrete. Identify whether any of the six retiring models is used in Copilot Chat, inline edits, ask mode, agent mode or code completions; record which Copilot plan and client govern each use; and distinguish named replacements from unresolved cases. Claude Fable 5, Claude Haiku 4.5, Gemini 3.8 Flash, Gemini 4 Argon and Grok 4.6 have suggested destinations in GitHub’s announcement. Kimi K3 does not yet have one, while individual annual-plan subscribers are expressly exempt from the Claude Haiku 4.5 deprecation. Those facts define the migration boundary for the next stage: testing whether the supported destination works for the engineering workflow, rather than assuming that a changed model label is a cosmetic update.

Why a model swap can change engineering output

A Copilot model is part of an engineering workflow, not merely a label in a picker. When GitHub replaces a retired model, the surrounding task may look unchanged while the system’s behavior shifts underneath it. The prompt still comes from the same editor or repository, but the replacement can interpret instructions differently, ask for different clarification, choose a different sequence of tools, or stop at a different point in an agent loop. Those differences matter when a task depends on a precise repository convention rather than a broadly acceptable answer.

That is why the retirement notice should be treated as a release-management event. The affected surfaces include Copilot Chat, inline edits, ask and agent modes, and code completions. A change on any of those surfaces can alter how an instruction becomes code, how existing files are searched before an edit, or how much context is used to justify a proposed change. The practical question is not whether the replacement can produce code. It is whether it produces the expected code, in the expected repository, under the same permissions and policy constraints.

The prompt is only part of the contract

Teams often think of a prompt as a request for an answer: fix a failing test, refactor a function, explain an API, or review a pull request. Mature Copilot workflows add an implicit contract around that request. The model is expected to follow repository instructions, preserve local style, respect scope, use available tools appropriately, and return a result that a human reviewer can verify. A model swap can affect each layer even when the written prompt is unchanged.

Prompt interpretation is the first source of variation. One model may infer that “make this change throughout the module” includes related tests; another may edit only the named function. One may treat a terse instruction as authorization to inspect neighboring files, while another may ask before widening the search. These are not necessarily defects, but they change how many decisions remain with the developer. A team that has quietly relied on one model’s interpretation may discover that its prompts were less explicit than its process assumed.

Tool use creates a second difference. In agent mode, output quality depends not only on the final text but also on the path taken to reach it: which files are opened, which commands are proposed or run, whether a test is executed, and how the model reacts to an error. A replacement that uses fewer tool calls may be faster but leave important assumptions unverified. One that uses more calls may improve investigation on difficult tasks while consuming more tokens and taking longer. GitHub’s supported-model documentation also makes clear that model availability depends on the Copilot plan and the surface where Copilot is being used, while availability can change as models are replaced or updated. That makes the effective workflow a combination of model, product surface and policy—not a model name alone.

Small behavioral changes can become workflow changes

Code style is another visible signal. Models can differ in how aggressively they refactor, where they place helper functions, how they name variables, and whether they preserve an existing pattern or introduce a new one. On an isolated suggestion, that may be a minor preference. Across repeated completions or inline edits, it can increase review noise and make a codebase’s conventions less consistent. The same applies to comments and tests: broader generated tests may be useful, but they can also expand diffs beyond what a reviewer expected.

Latency and token consumption belong in the same evaluation. A response that is technically correct but materially slower can change whether developers use Copilot for small tasks. A response that consumes more context or produces longer diffs can affect usage patterns and cost controls. The retirement notice does not establish a particular performance or cost outcome for every replacement, so those effects should be measured rather than assumed.

Review quality deserves separate attention because review is a judgment task, not just code generation. A replacement model may emphasize different risks, phrase findings differently, or miss a defect that the previous model surfaced. It may also identify an issue that was previously overlooked. “The code still compiles” is therefore an inadequate migration test. Teams should compare representative review findings, explanations, false positives and omissions before assuming that an unchanged review workflow has unchanged coverage.

The 2026 migration study in the research plan adds a warning about timing: its analysis found that most observed migrations in open-source applications happened after the original model was shut down. That finding is context, not a prediction that every Copilot user will respond the same way. Its operational implication is straightforward: waiting until retirement is enforced removes the period in which a team can compare outputs while the old behavior is still available as a reference. Testing beforehand turns an unexpected production change into a controlled comparison.

The safest mental model is behavioral compatibility, not model-name compatibility. GitHub’s documentation can establish which models and policies are supported, but it cannot prove that a replacement preserves a team’s prompt interpretation, agent loop, style, latency, token use or review quality. Those properties have to be checked against the work the team actually performs. A model retirement becomes manageable when engineering leaders treat the replacement as a version change in an AI-assisted toolchain and validate the parts of that toolchain that people, automation and policy depend on.

Who needs to act before the deadline

The deadline is not only a reminder for individual developers. It is an ownership question: who controls the model choice, who depends on the current behavior, and who can verify that a replacement still fits the workflow? GitHub’s retirement notice covers Copilot Chat, inline edits, ask and agent modes, and code completions. The responsible audience is therefore broader than people who occasionally open a model picker. Enterprise administrators, platform teams, repository owners, and developers may each control a different part of the configuration.

Enterprise administrators should begin with the policies that determine which models users can see and use. The key distinction is between an explicitly selected model and a default model inherited through organizational settings. A named model may appear in a policy, a documented standard, a saved instruction, or an integration even when most users experience Copilot through a default. Those references need to be found before the retirement date. A default can change centrally, while an explicit choice may remain embedded in a workflow or fail when the named model is no longer available.

The administrative review should also cover plan eligibility and restrictions affecting replacement models. GitHub’s supported-model documentation makes availability and policy controls part of the model-selection picture, so availability should not be assumed from another user’s account or from a product screenshot. Check the organization’s Copilot plan, the models permitted by policy, and any data-residency or compliance requirements that narrow the available choices. If a replacement is unavailable under a particular plan or conflicts with an organizational restriction, the migration path may differ from the one suggested by a general announcement.

Platform teams have a separate responsibility: identify the places where Copilot is part of an engineering system rather than an individual convenience. This includes pinned model settings in extensions or integrations, shared prompt files, internal developer guidance, pull-request automation, and evaluation jobs that record results under a model name. A model reference can be hidden in a configuration value, policy rule, or test harness. Inventorying those references helps distinguish an intentional default from a dependency that could fail or silently change.

The highest-priority review belongs to workflows with an operational consequence. Agent modes can interpret prompts, use tools, repeat steps, and stop under different conditions after a model change. Code-review workflows can produce different findings, priorities, or explanations even when the underlying code is unchanged. Automated evaluations can also become misleading if they compare results from one model with historical results from another without recording the change. These possibilities do not establish that a replacement will fail; they establish that the replacement deserves an owner and a check.

Teams should list every workflow that assumes a named model, not merely every workflow that displays one. A developer choosing a model for an occasional explanation may only need to confirm that a supported replacement is available. A platform team running agent tasks, review assistance, or repeatable prompt evaluations needs to define what “equivalent” means for that workflow and identify who will approve the result. Relevant checks can include correctness on representative tasks, tool-call behavior, latency, token use, permissions, and review quality.

Individual developers still have a concrete role before the cutover. They should inspect saved prompts, personal instructions, editor settings, and documented model preferences used in daily work. They should also flag team prompts or examples that name a retiring model, particularly when those prompts are copied into shared repositories or onboarding material. A replacement visible in the interface is not automatically validated for a project’s coding conventions, test expectations, or review habits. Developers are often best placed to notice those small but consequential differences.

A useful escalation rule is simple: the more a workflow can act, gate, or publish, the less acceptable it is to treat model retirement as a cosmetic UI update. An agent workflow that edits files, a review process that influences merge decisions, or an evaluation pipeline used to compare prompt changes has a larger operational impact than an ordinary chat session. Those owners should record the current model, the intended replacement, the policy enabling it, and the evidence that the workflow remains acceptable after the change.

Before December 14, administrators can confirm policy inheritance and replacement eligibility; platform teams can search configurations, integrations, prompts, and evaluations; and developers can test recurring Copilot tasks. The objective is not to preserve a model name for its own sake. It is to make the dependency visible, assign responsibility for the affected workflow, and ensure that any change in output is noticed by the people who rely on it.

A controlled migration checklist for Copilot users

Treat the December 14, 2026 cutover as a small release-management exercise, even if GitHub presents it as a model-availability change. The first task is to establish where the retiring models are actually referenced. Search administrator policies, repository or organization documentation, saved prompts, internal runbooks, evaluation scripts and integrations that pass a model name explicitly. Also record places where a model is selected as a default rather than named in code or configuration. A visible model picker is only one part of the dependency surface: a team may have standardized prompts, agent instructions or review procedures around a particular model without documenting that assumption.

Inventory should produce an owner and a decision for each reference. The owner might approve GitHub’s replacement, select another supported model, or remove the explicit pin and allow the applicable policy to govern the choice. That decision should account for plan eligibility and any organization rules that limit which models can be used. It should also identify integrations whose behavior depends on a model being available. A replacement that appears in a user interface is not automatically available in every plan, policy scope or workflow, so the inventory should be checked against GitHub’s current supported-model documentation and the organization’s own Copilot settings.

1. Make the replacement explicit

Do not rely on a silent fallback for important engineering work. Enable or explicitly approve the intended replacement in the relevant organization, enterprise or personal settings, then verify that the setting reaches the users and repositories that need it. If a policy is inherited, record where the effective value comes from and who can change it. This matters particularly for enterprise administrators: a developer’s local selection may not override an organization policy, while a centrally changed policy may affect many workflows at once.

For every named model, capture the expected behavior after the change. The record can be short: replacement model, affected Copilot surfaces, policy owner, plan or eligibility constraint, and fallback behavior if the replacement is unavailable. Include the exception cases identified in GitHub’s notice rather than assuming that all accounts follow the same path. The goal is not to preserve a particular label at any cost; it is to make the post-cutover state deliberate and visible.

2. Test representative work, not toy prompts

Build an evaluation set from real tasks that matter to the team. Include ordinary code completion, multi-file changes, debugging, explanation, test generation, code review and any agent workflow that uses tools or repository context. Preserve the prompt, relevant files or fixtures, expected outcome and acceptance criteria so that the old and replacement configurations are compared on the same work. A handful of impressive demonstrations is not enough to establish that a migration is safe.

Evaluate correctness first, but do not stop there. Record whether the response follows repository conventions, whether it asks for clarification at the right time, whether it proposes unnecessary changes and whether a reviewer can understand the resulting patch. For agent modes, check the complete loop: interpretation of the request, tool selection, permission prompts, file changes, test execution and stopping behavior. These checks are practical consequences of the fact that models can differ in prompt interpretation, tool use and agent behavior even when they are offered through the same Copilot surface.

Latency and token consumption belong in the same comparison. A model that produces an acceptable answer but takes longer, consumes more context or causes additional iterations can change the cost and throughput of a workflow. Record enough evidence to distinguish a one-off response from a repeatable pattern. If the team already has automated evaluations, run the migration through those tests and retain the results; if it does not, a small manually reviewed set is still more useful than an unverified assumption that the replacement is equivalent.

3. Check permissions, policy and fallback behavior

A migration test should exercise the permissions that the workflow will have in production. Confirm that the replacement can access the expected repository context and tools, and that approval gates still behave as intended. Test both a successful path and a constrained path: for example, what happens when a tool call requires approval, when a model is not enabled for the account, or when an administrator policy prevents a preferred selection? The result should be recorded as an operational behavior, not left to individual developers to discover during a live task.

Document rollback or fallback behavior before the deadline. In this case, rollback may not mean restoring a retired model; it may mean switching to another supported model, disabling an automated step, routing a task for human review or temporarily using a narrower workflow. The important point is that the team knows which action is safe when the expected model is missing or produces materially different output. Avoid treating an untested fallback as a control: a fallback can change code style, review depth, latency or usage patterns just as a primary replacement can.

4. Communicate the cutover and verify it afterward

Tell affected developers, reviewers and administrators what is changing, when it takes effect and which workflows require attention. The communication should link to the approved replacement or policy, identify the owner for questions and point to the evaluation results. It should also say what users should report: unavailable models, unexpected agent behavior, changed review output, new approval prompts, unusual latency or a noticeable increase in usage. Clear reporting criteria make it easier to separate a normal model difference from a configuration defect.

After December 14, perform a post-change check rather than closing the task when the deadline passes. Confirm that the retired models no longer appear where they should not, that the intended replacements are available to the right accounts and that policy inheritance still resolves to the expected value. Re-run a small representative subset of the evaluation set, inspect one or more real code-review and agent workflows, and compare usage or cost signals with the pre-change baseline. Finally, update saved prompts, runbooks and internal documentation so that the next model change starts from an accurate inventory. That final verification turns a forced retirement into a controlled change with an observable outcome.