GPT-5.5 Leaves Codex on Oct 14? Migration Checklist (2026)

If you use GPT-5.5 in Codex through a ChatGPT sign-in, audit your model selection, scripts, and team defaults before October 14, 2026, then test an account-visible replacement on real tasks. If your Codex session uses an API key, or you call the OpenAI API directly, the announced change does not apply to that access path.

This guide is for individual developers using ChatGPT sign-in in Codex, engineers maintaining scripts or custom Agents, and platform owners managing model access. If you only use the API, check the separate API notes before changing your integration.

Last updated October 13, 2026. The retirement date, affected products, and API exception were checked against the official model documentation and OpenAI’s update notes. Check those sources again before you make a rollout decision in case the stated scope changes.

GPT-5.5 Codex migration starts with your sign-in path

The announced change is not a general shutdown of OpenAI Codex. The official model information says GPT-5.5 leaves ChatGPT, ChatGPT Work, and Codex when you sign in with ChatGPT on October 14, 2026. It also says GPT-5.5 remains available through the OpenAI API. Those distinctions decide what you need to change. (Model documentation; update notes)

Think of your setup as separate access routes, not one product switch:

• ChatGPT-signed-in Codex: The stated retirement scope includes this route. Check the selected model and prepare a replacement in the account and client you use.
• API-key-authenticated Codex session: This is a different authentication path from ChatGPT sign-in. The published exception concerns API access, so verify the active authentication method and model setting rather than assuming every Codex session changes.
• Direct API integration: The API model page says GPT-5.5 remains available through the API. This retirement notice alone does not mean you must rewrite a working API integration. (GPT-5.5 API model information)

The three named product surfaces—ChatGPT, ChatGPT Work, and ChatGPT-signed-in Codex—are the documented retirement scope. The API is explicitly distinguished from them. Use the API deprecation documentation as a separate check for any API-specific retirement notice; don’t infer an API shutdown from a ChatGPT product change.

Important: An API key appearing somewhere in your workflow does not prove that every Codex client session uses API-key authentication. Check the credential and sign-in state attached to the specific session that runs your work.

Before October 14, make an inventory you can compare

Start with discovery, not a model swap. A hidden pinned value can leave a developer, scheduled task, or team template pointing at a model that is no longer selectable in the affected sign-in flow.

Search every place that can set a model or authentication method:

• Codex CLI commands, shell scripts, task runners, and scheduled jobs.
• IDE and desktop client preferences, including project-specific settings.
• User-level and repository-level configuration files.
• Environment variables, secrets references, and wrapper scripts that launch Codex.
• Custom Agent definitions, prompts, and tool-routing rules.
• Team defaults, onboarding instructions, and administrator access policies.

Codex’s configuration basics explain where configuration can be set. Use the configuration reference to inspect supported keys, and the CLI reference to verify command-line options rather than relying on old examples copied into scripts.

Record the current setup beside each finding. Include the client, project, authentication route, model setting, and the person or job that depends on it. If you find the same model selection in several places, don’t assume they inherit from one shared setting. Confirm which file, argument, or account preference wins in the actual launch path.

Then capture a small set of representative tasks before changing anything. Save the repository revision or test fixture, task prompt, available tools, permissions, expected output, and acceptance result. Include ordinary work and at least one task that has previously exposed a failure, such as a patch that needs a test run or a tool call that requires review. The goal is a repeatable comparison, not a benchmark claim.

Choose the next step from the access route

Use these conditions to decide what to do:

• If the affected session signs in with ChatGPT and selects GPT-5.5, prepare to change its model selection before October 14. Confirm that a replacement is available to the account and client, then run your saved task set.
• If the session authenticates with an API key, verify the active credential and API model setting. Keep the API route only if it is intentional, permitted by your organization, and still works in a direct test.
• If you call the API directly, don’t change the integration solely because of the ChatGPT/Codex retirement notice. Confirm the current model availability and check the API deprecation notices independently.
• If you cannot establish which route a script uses, pause its rollout. Inspect its configuration and authentication in a safe test run before editing production settings.
• If no account-visible replacement is available, ask the account or platform administrator to confirm access. Until then, retain a tested API-based route if your use case and policy allow it; otherwise, schedule a manual pause rather than letting a job fail without a known fallback.

These branches avoid a common migration mistake: changing the client, credential, and model at the same time. Change one variable at a time where possible. That makes it easier to identify whether an error comes from access, configuration, or changed model behavior.

During the change, verify availability before editing shared defaults

A model listed in a general announcement is not a guarantee that it is selectable for every user, plan, client version, or organization. Treat account and client availability as a check you must perform. The official model page is the source for stated availability; the session you actually use is the evidence for your local rollout.

Before changing a shared configuration:

• Open the affected Codex client under the intended account and confirm the available model choices.
• Check that the client version recognizes the selected model and configuration keys.
• Ask an administrator to confirm that organizational policy permits the intended option.
• Test the replacement in a non-production project or a controlled branch.
• Update one representative user or job first, then check the result before changing the team default.

Do not treat an announcement’s suggested alternative as a promise that it will behave identically for your coding workload. A model can be available yet differ in how it edits files, requests tools, follows repository instructions, or reports a failed command. Your acceptance check should be based on the work you need it to do.

After changing models, rerun the same coding work

Use the saved task set with the replacement selected. Keep the repository state, permissions, tool availability, and test commands consistent. If those inputs change too, you will not know whether a different result came from the model or the environment.

For every task, inspect four things:

• Code changes: Does the patch stay within the requested scope? Are unrelated files changed? Does the result need more manual correction than the baseline?
• Tests and commands: Did Codex invoke the expected tests or commands? Did they complete, fail, or get skipped? Confirm outcomes in the terminal or CI log rather than trusting a summary.
• Tool behavior: Did the session use the intended tools and request approval when your policy requires it? Check whether a script or custom Agent assumes a particular tool-call sequence.
• Failure handling: When the task cannot proceed, does the client identify the missing permission, unavailable tool, or invalid configuration clearly enough for an operator to act?

Keep a short migration record for each task: input, model and authentication route, result, tests, manual corrections, and pass/fail decision. Flag cases that need human review. Don’t describe the replacement as equivalent or faster unless you have evidence from your own controlled evaluation. This is especially important for custom Agents, where a small change in tool selection or output format can break downstream automation even if the final answer looks plausible.

If you need a repeatable way to structure those acceptance checks, vmzig’s guide to testing AI coding Agent changes offers a related acceptance-testing reference. Adapt the test design to your own Codex workflow; it is not a GPT-5.5 benchmark or a claim about replacement-model performance.

Keep API access and rollback separate from ChatGPT sign-in

Document two recovery actions, because they solve different problems. A model-selection problem in ChatGPT-signed-in Codex may require changing the session’s model or account policy. An API integration issue may require checking the API model name, credentials, permissions, and API-specific notices. A direct API route is not an automatic fallback for a ChatGPT session unless you have built and tested that path.

For each script or custom Agent, decide what it should do when its chosen model is unavailable:

• Stop with a clear error and tell the operator which configuration to inspect.
• Switch to a pre-approved, account-visible model only if that fallback has passed your task checks.
• Route to an API integration only if the script is explicitly designed and authorized to use API credentials.
• Avoid silently changing authentication or sending work to a different route.

The OpenAI API model page is the reference for GPT-5.5’s API availability, while the separate API deprecation list is where you should check API-specific changes. Keep those references in your runbook so the next operator can tell product retirement from API lifecycle changes.

Update team documentation after the test passes. Include where the model is configured, which users or jobs are affected, what fallback is approved, and who owns the access decision. Add a comment to scripts that explains whether they expect ChatGPT sign-in or API-key authentication. That prevents the next maintainer from “fixing” an access issue by swapping credentials without understanding the policy consequences.

Compare routes before closing the migration

Access route	What the October 14 notice says	What you should verify
ChatGPT-signed-in Codex	Included in the stated GPT-5.5 retirement scope.	Selected model, account access, client availability, and tested replacement.
API-key Codex session	Distinct from ChatGPT sign-in; verify the session’s actual authentication route.	Credential source, API model setting, policy approval, and script behavior.
Direct OpenAI API	GPT-5.5 remains available through the API according to the official model page.	Current API model availability, credentials, and separate API deprecation notices.

The table is a routing aid, not a substitute for checking the live account. Availability can be affected by your own account settings and administrator policy. If you cannot verify a route, treat it as unknown and resolve that uncertainty before relying on it in an automated job.

Frequently asked migration questions

Does the API stop working when GPT-5.5 leaves Codex?

No. The official model information states that GPT-5.5 remains available through the OpenAI API after the October 14, 2026, retirement from ChatGPT, ChatGPT Work, and Codex sessions signed in with ChatGPT. Verify the model name and account access in the current API documentation. An API-key Codex session is a separate access route from a ChatGPT-signed-in session.

How can you tell whether your Codex session is affected?

Check how that specific session authenticates, not only which client you open. A Codex session signed in with your ChatGPT account is within the stated retirement scope. A session authenticated with an API key is a separate route. Confirm the active credential and model in the client or script that runs your work before deciding whether you need to migrate it.

What settings and scripts should you check before replacing GPT-5.5?

Search user and project configuration, CLI arguments, IDE and desktop preferences, environment variables, task runners, team templates, and custom Agent definitions. Record where the model is pinned and which authentication route each job uses. Also inspect error handling: a script that assumes one fixed model may fail without a useful message when that selection is no longer available.

How do you validate existing coding tasks after a Codex model change?

Run the same tasks against the same repository state with the replacement model, tools, permissions, and test commands unchanged. Inspect the patch, whether tests ran, tool-call behavior, and failure messages. Record manual corrections and require human review where needed. Treat any observed difference as a migration finding, not proof that one model is generally better.

Plan the runtime environment without confusing it with model access

A model migration is primarily an account, client, and configuration change. Moving a task to another computer does not restore a retired model in a ChatGPT sign-in flow, and renting a Mac does not grant model access by itself. Keep those decisions separate.

Your current development machine may still be the simplest option if its environment is stable and you can validate the workflow there. But a shared or heavily used machine can make regression runs harder to reproduce; local settings may differ between developers; and access to a suitable test machine may depend on internal scheduling or permissions. If those are your actual constraints, a temporary Mac environment can help isolate the operating system and project setup while you test. It cannot replace the account-level model availability check.

If you need a separate Mac for a short-lived regression environment, review vmzig’s Mac rental options and confirm that the environment fits your tooling and access requirements before relying on it. For setup or access questions, use the vmzig help guide. Keep the migration decision grounded in your tested Codex route: move to an alternative only after it is available to the intended users and has passed the tasks that matter to your team.

FAQ

Will GPT-5.5 still be available through the API after it leaves Codex?

Yes. The official model information says GPT-5.5 will remain available through the OpenAI API after its October 14, 2026, retirement from ChatGPT, ChatGPT Work, and Codex sessions signed in with ChatGPT. Verify the model name and your API account’s access in the current API documentation. A separate API-key Codex session is not the same access path as a ChatGPT-signed-in session.

How can I tell whether my Codex session is affected?

Check how the session authenticates, not just which Codex client you open. A Codex session signed in with your ChatGPT account falls within the stated retirement scope. A session authenticated with an API key is a separate path, and the API model documentation says GPT-5.5 remains available there. Confirm the active model and authentication method in the client or script you actually use.

What should I update when replacing GPT-5.5 in Codex?

Search your user and project configuration, CLI arguments, IDE settings, desktop preferences, environment variables, task runners, and team templates for a pinned GPT-5.5 selection. Also inspect custom Agent prompts and error handling. Record the existing task inputs and acceptance results before changing anything, so you can compare behavior and restore a known configuration if the replacement is unavailable.

How should I validate coding tasks after changing the Codex model?

Run the same representative tasks with the replacement model and the same repository state, tools, permissions, and test commands. Compare the resulting patch, whether tests ran, tool-call behavior, and the clarity of failure messages. Treat any change in behavior as something to review, not as proof that one model is better. Keep human review in the loop for consequential code changes.