GPT-5.5 Retirement Set for October 14: Product-Surface Deadline, Codex Replacements, and the API Boundary

OpenAI Sets an October 14 Product-Surface Deadline for GPT-5.5

OpenAI’s official ChatGPT account posted on September 15, 2026 that GPT-5.5 will be retired on October 14, 2026 in ChatGPT, ChatGPT Work, and Codex across all plans. That is a product-surface retirement notice, not a broad license to infer every surrounding lifecycle detail. The post names the affected surfaces, gives the retirement date, and provides replacement guidance for Codex users; it does not, by itself, settle API lifecycle, pricing, limits, workspace policy, prompt compatibility, tool behavior, or continuity for existing work.

The practical deadline is therefore straightforward but narrow: if a user or team currently selects GPT-5.5 inside ChatGPT, ChatGPT Work, or Codex, they should treat October 14 as the date by which that product selection must be retired or replaced. Administrators should not wait until the final week to discover where GPT-5.5 appears in saved prompts, Codex workflows, workspace defaults, team instructions, training material, screenshots, evaluation sheets, or support runbooks. Model retirement is often operationally small for casual users and operationally significant for organizations that have embedded model choice into repeatable workflows.

For Codex specifically, OpenAI’s September 15 post explicitly tells users of GPT-5.5 to switch to GPT-5.6 Sol or GPT-6 Astra. That replacement guidance is limited to Codex usage in the notice. Teams should not generalize it into a claim that every ChatGPT or ChatGPT Work workspace will expose the same replacement options, that the replacements will behave identically to GPT-5.5, or that every tool-using flow will preserve the same affordances without testing.

This article explains how to migrate from GPT-5.5 and GPT-5.6 Sol to GPT-6 Astra, covering Responses API compatibility, reasoning, caching, model identifiers, access checks, and production-readiness concerns. The How to Migrate from GPT-5.5 and GPT-5.6 Sol to GPT-6 Astra: Responses API, Reasoning, Caching, and Compatibility article is a focused companion for GPT 5.5 to GPT 6 Migration because it is the most direct match for a GPT-5.5-to-GPT-6 migration path and supports the current article’s retirement-and-replacement framing.

This article’s opening section separates what OpenAI has confirmed from what remains an implementation question. The distinction matters because retirement planning fails when teams treat a public post as a complete migration contract. A confirmed date can justify an inventory and test plan; it cannot justify assumptions about automatic migration, prompt parity, cost equivalence, context handling, coding behavior, workspace visibility, or API status unless OpenAI’s current product documentation and account-specific notices say so.

Confirmed Facts from the September 15 Notice

The confirmed facts are compact enough to list precisely. The notice came from the official @ChatGPT account on September 15, 2026. It states that GPT-5.5 will be retired on October 14, 2026. It names ChatGPT, ChatGPT Work, and Codex as affected product surfaces. It says the retirement applies across all plans. For GPT-5.5 use in Codex, it recommends switching to GPT-5.6 Sol or GPT-6 Astra.

The scope is also important. “Across all plans” in the post means teams should not assume that a higher-tier plan, an enterprise workspace, or a legacy configuration will keep GPT-5.5 available in those named surfaces after the retirement date. Workspace administrators should still inspect their own product notices and model selectors because availability and policy can vary by account, workspace settings, app surface, and rollout, but the public retirement notice should be treated as the controlling planning signal for the named product surfaces.

OpenAI’s model release notes and model documentation remain the places teams should check for current model status, release history, and surface-specific availability. The September 15 post is the news trigger; the current documentation and in-product controls are the operational evidence teams need before making changes. A founder deciding whether to update customer support macros, an enterprise administrator revising workspace guidance, and a security lead reviewing Codex workflows all need the same discipline: record what the official notice says, then verify what the account actually exposes.

What the Notice Does Not Confirm

The notice does not announce an API retirement for GPT-5.5. That does not mean the API is permanently unaffected, and it does not mean API users can ignore model lifecycle documentation. It means this particular September 15 product-surface notice should not be rewritten into an API deprecation claim. Developers using GPT-5.5 through an API path should inspect the current API model documentation, current deprecation notices, and account-visible model availability before changing production systems.

The notice also does not confirm a universal automatic migration. OpenAI did not state in the September 15 post that existing conversations, saved tasks, Codex sessions, workspace defaults, custom instructions, tool configurations, or user selections will be automatically moved to a replacement model. Even if a product later presents an in-app migration path, teams should test the result rather than assume continuity. A saved workflow that depends on a particular reasoning style, tool call pattern, code-editing habit, or response format can break quietly if its underlying model choice changes.

Behavioral parity is not confirmed. GPT-5.6 Sol and GPT-6 Astra are named as Codex replacements for GPT-5.5 use, but the post does not say they will match GPT-5.5 on coding style, latency, refusal behavior, tool usage, repository navigation, edit granularity, instruction following, or error modes. Security teams and engineering managers should treat replacements as new operating choices that require evaluation against representative tasks, not as drop-in equivalents unless their own testing supports that conclusion.

Pricing parity and limit parity are not confirmed. The September 15 post does not state that GPT-5.6 Sol or GPT-6 Astra will have the same pricing, usage limits, rate behavior, credit consumption, or workspace controls as GPT-5.5. Product limits can depend on plan, workspace policy, region, app, rollout, and administrative configuration. Teams with budgets, internal chargeback, or managed usage policies should collect current account-specific evidence before approving broad replacement guidance.

This article covers OpenAI’s removal of automatic thinking escalation for Plus and Pro users and explains how explicit model-picker choices affect GPT-5.6 and GPT-6 workflows. The ChatGPT Retires Automatic Thinking for Plus and Pro: How the Explicit Model Picker Changes GPT-5.6 and GPT-6 Workflows article is a focused companion for Explicit Model Selection because the marker is specifically about explicit model selection, and this target directly addresses model-picker behavior rather than general model comparison.

Confirmed Versus Not Confirmed

The table below is a planning boundary, not a substitute for account-specific verification. Use it to brief stakeholders without overclaiming what OpenAI has announced. For each row, the right response is to translate the public fact into an internal action: inspect the model picker, review workspace controls, update runbooks, run regression tests, or monitor official documentation.

Why This Is a Product-Surface Retirement, Not an API Migration Announcement

The phrase “in ChatGPT, ChatGPT Work, and Codex” should be read carefully. Those are product surfaces where users interact with model choices through app interfaces, workspace controls, and Codex workflows. API usage has its own lifecycle signals, documentation, and deprecation notices. A team that operates both a ChatGPT Work deployment and an API-backed product should create two separate workstreams: one for product-surface inventory and one for API lifecycle verification.

The product-surface workstream should begin with visible usage points. Administrators and team leads should identify where users manually choose GPT-5.5, where internal instructions tell users to choose it, where screenshots or training videos reference it, and where Codex workflows depend on it. The aim is not to prove every past conversation will fail after October 14; the aim is to remove a soon-to-retire selection from active operational guidance before the deadline.

The API workstream should not assume safety from silence. If a developer has hard-coded a GPT-5.5 model identifier, pinned it in a deployment configuration, included it in evaluation matrices, or documented it in customer-facing material, that usage deserves a lifecycle check even though the September 15 post does not announce an API retirement. The safe rule is simple: do not claim an API deadline from the product notice, and do not claim indefinite API continuity from the absence of an API deadline in that notice.

Codex Teams Should Treat GPT-5.6 Sol and GPT-6 Astra as Replacement Candidates, Not Untested Clones

OpenAI’s explicit Codex guidance is the most actionable part of the notice: switch GPT-5.5 use in Codex to GPT-5.6 Sol or GPT-6 Astra. Engineering teams should turn that guidance into a controlled comparison, especially where Codex participates in code generation, refactoring, code review preparation, test writing, documentation updates, repository analysis, or multi-step debugging. The comparison should use approved repositories, least-privilege access, and tasks that resemble real work without exposing unnecessary secrets or regulated data.

A minimal Codex replacement test should include a small set of representative prompts, expected outputs, and review criteria. For example, a backend team might test whether the replacement model correctly identifies the relevant files, proposes a minimal patch, preserves existing style, writes or updates tests, explains assumptions, and avoids broad rewrites. A documentation team might test whether the model preserves product terminology, flags uncertainty, and avoids inventing API behavior. A security team might test whether the model refuses unsafe credential-handling instructions and avoids exposing sensitive file paths in generated explanations.

Human approval remains mandatory for consequential operations. A model replacement should not be allowed to merge code, publish content, change permissions, send external messages, delete data, modify infrastructure, or execute privileged actions without an authorized human review step. Retirement pressure is not a reason to weaken change control; it is a reason to make the model selection explicit and to preserve evidence of the test results.

Immediate Actions Before October 14

Recommendation: start with an inventory, not a mass rewrite. List every place where GPT-5.5 is named or selected: ChatGPT instructions, Work onboarding material, Codex task templates, internal prompt libraries, support procedures, screenshots, evaluation sheets, training decks, automation notes, and developer documentation. Mark each item as “remove,” “replace with tested model,” “needs owner decision,” or “historical reference only.”

Recommendation: run replacement tests on the highest-risk workflows first. High-risk workflows include anything involving code changes, customer-facing outputs, regulated content, financial analysis, legal or HR material, security review, permission changes, external communications, and publication. Low-risk conversational exploration can often be handled with lighter guidance, but teams should still avoid telling users to select a retired model after the deadline.

Recommendation: preserve rollback evidence without assuming a platform rollback will exist. Keep prompt versions, test inputs, selected replacement models, reviewer notes, output samples, failure cases, and approval records in your own controlled system. If a replacement produces regressions, that evidence helps teams adjust prompts, select a different available model, change review gates, or escalate through support channels. It also prevents migration discussions from collapsing into subjective impressions.

Operational warning: do not benchmark replacements casually and publish the results as universal truth. The September 15 notice does not provide benchmark data, and internal tests are shaped by task design, repository quality, reviewer expectations, workspace settings, and current rollout state. Teams can use local evaluations for local decisions, but they should label them as such and avoid presenting them as official OpenAI performance claims.

The Bottom Line for Developers, Admins, and Advanced Users

By October 14, 2026, GPT-5.5 should no longer be treated as an available model choice in ChatGPT, ChatGPT Work, or Codex across plans. Codex users have explicit replacement direction from OpenAI: evaluate GPT-5.6 Sol or GPT-6 Astra for GPT-5.5 use. Everyone else should verify the current product model picker, workspace controls, model release notes, and model documentation before updating guidance.

The most common mistake will be over-reading the announcement. The notice is enough to trigger a migration plan; it is not enough to assert API retirement, automatic migration, behavioral parity, preserved prompts, identical limits, or guaranteed replacement availability in every workspace. The safest response is a disciplined inventory, explicit model selection, representative regression testing, and human review for every workflow where a model change can affect code, customers, compliance, security, spending, or publication.

Migration boundary: The notice does not guarantee parity across GPT-5.5, GPT-5.6 Sol, and GPT-6 Astra, so teams should not assume parity in prompts, outputs, tools, limits, or cost. It also does not promise automatic migration; automatic migration is not guaranteed, and each saved workflow must be inventoried and tested.

Inventory Every GPT-5.5 Dependency Before You Choose a Replacement

The safe migration unit is not “the model”; it is the full product surface where GPT-5.5 is selected, remembered, invoked, constrained, or assumed. OpenAI’s official retirement notice names ChatGPT, ChatGPT Work, and Codex across all plans, and it gives Codex users two replacement candidates: GPT-5.6 Sol or GPT-6 Astra. That notice does not say your existing chats, Work tasks, Codex projects, saved instructions, tools, permissions, limits, or budgets will behave the same after a switch. Treat every GPT-5.5 dependency as an asset with an owner, a risk level, a test case, and a decision deadline.

Recommendation: create one retirement inventory that covers interactive use, scheduled or recurring work, software-development flows, workspace administration, and cost controls. Do not let each team improvise its own spreadsheet if the workspace has shared plugins, shared repositories, shared skills, or shared budget ceilings. A single inventory lets administrators see where GPT-5.5 is still selected, where a replacement has been tested, and where the October 14 deadline could interrupt a real workflow.

The inventory should distinguish “explicit selection” from “behavioral dependence.” An explicit selection is a visible model choice, a saved project setting, or a task configuration that names GPT-5.5. A behavioral dependence exists when a team says a workflow “only works well” with GPT-5.5 even if the current interface later hides the original selection. Both matter, because the first can break at selection time and the second can break at quality, reasoning, tone, tool-use, or review time.

This article explains how ChatGPT Work and Codex starting defaults are configured, including models, reasoning, fast mode, roles, local access, cloud access, and entitlement boundaries. The Configure ChatGPT Work and Codex Starting Defaults: Models, Reasoning, Fast Mode, Roles, Local Access, and Cloud Access article is a focused companion for Codex Model Selection because it fits Codex model selection because it focuses on Codex defaults and model/reasoning configuration rather than unrelated coding-agent usage.

Use a Dependency Register That Separates Facts from Assumptions

A retirement register should record what is known from the product today, what is inferred from user behavior, and what still needs verification. The official notice confirms the retirement scope and the Codex replacement recommendation, but it does not confirm replacement parity or automatic migration. Your register should therefore include a field for “source of evidence” and a field for “untested assumption.” If a team writes “replacement should be fine,” require a test reference or mark the dependency as unresolved.

{
  "dependency_name": "Internal release-note drafting workflow",
  "surface": "ChatGPT Work",
  "current_model_reference": "GPT-5.5",
  "replacement_candidate": "To be tested",
  "business_owner": "Named communications owner",
  "technical_owner": "Workspace administrator",
  "data_or_tool_access": "Approved workspace sources only",
  "risk_level": "Medium",
  "baseline_artifacts": [
    "approved prompt",
    "representative input",
    "human-reviewed expected qualities",
    "previous acceptable output"
  ],
  "required_approvals": [
    "business owner",
    "security reviewer if confidential material is included"
  ],
  "test_status": "Not started",
  "open_assumptions": [
    "Tone remains acceptable",
    "Model follows publication approval instruction",
    "No unsupported claims are introduced"
  ],
  "decision_deadline": "Before October 14 retirement"
}

Operational warning: do not put secrets, tokens, private customer records, health information, account numbers, or privileged legal material into the inventory itself. The register should point to approved evidence locations and data classes, not reproduce sensitive content. If a regression test requires confidential material, use an approved workspace, least-privilege access, and a redacted evidence packet for migration sign-off.

Chat and Work Task Inventory: Preserve Intent, Not Just Text

For ChatGPT and ChatGPT Work, teams often depend on conversational context rather than a formal prompt. Inventory the job the chat performs: “draft customer-safe incident updates,” “summarize policy exceptions,” “compare vendor proposals,” or “prepare leadership questions for a forecast review.” A long conversation is not automatically a reusable workflow; identify the prompt segment, the source material type, the decision being supported, and the human approval step that makes the output usable.

Recommended fields for chat and Work tasks: current model if visible, task purpose, prompt owner, data sensitivity, required sources, output format, prohibited claims, required disclaimers, approval owner, and evidence location. For Work tasks that touch business documents or connected tools, add the data owner and the permission boundary. A replacement model that writes fluently but ignores a required source restriction has not passed migration.

Representative chat tests should include at least one ordinary case, one ambiguous case, one sensitive-data boundary, and one refusal-or-escalation case. For example, a policy assistant should be tested on a straightforward summary request, a request with conflicting source documents, a request that asks for unnecessary personal data, and a request to send the answer externally. The expected behavior is not just “good answer”; it is source-bounded reasoning, clear uncertainty, no unnecessary disclosure, and no external action without human approval.

Codex Inventory: Treat Replacement Selection as an Engineering Change

For Codex, the official notice explicitly recommends switching GPT-5.5 use to GPT-5.6 Sol or GPT-6 Astra. That is replacement guidance, not a guarantee that either candidate will produce the same patches, test choices, command plans, or review comments. Engineering teams should run both candidates where available under the same repository constraints, the same branch policy, the same test commands, and the same human review rubric. If one candidate is unavailable in a workspace, record that as a product-surface availability fact rather than assuming global access.

Codex inventory should cover projects, repositories, issue classes, review tasks, generated tests, refactors, dependency updates, documentation generation, migration scripts, and release-support workflows. Add repository sensitivity: public, internal, regulated, customer-specific, security-critical, or privileged. Security-critical repositories should require stricter acceptance thresholds because a plausible patch can still be unsafe, overbroad, or difficult to review.

Codex regression examples: ask the candidate model to explain a small bug before editing; generate a minimal patch on a test branch; update a unit test; review a pull request for risk; summarize the diff for a maintainer; and identify what it did not verify. A passing run should keep changes scoped, avoid unrelated rewrites, preserve existing style, provide a reviewable rationale, and defer merge or deployment to authorized humans.

Plugins, Skills, Tools, and Repositories Need Tool-Use Tests, Not Just Prompt Tests

A model retirement can expose hidden coupling between a prompt and a tool. The prompt may still read well, but the replacement model may choose a tool too early, skip a needed clarification, pass incomplete arguments, overtrust a retrieved document, or fail to state that an action requires approval. Inventory each plugin, skill, and tool with its owner, purpose, permission scope, allowed data classes, prohibited operations, logging expectation, and approval path.

Tool regression test design: include a no-tool case, a required-tool case, an insufficient-permission case, a conflicting-source case, and an external-action case. In the no-tool case, the model should answer from supplied context without reaching into connected systems. In the required-tool case, it should use the authorized source or state that it cannot complete the task. In the insufficient-permission case, it should not ask the user to paste credentials or bypass access controls. In the external-action case, it should prepare a draft or plan and require human approval before sending, publishing, purchasing, changing permissions, deleting, merging, or deploying.

Repositories deserve their own inventory line even when they are reached through Codex projects. Record default branch protections, required reviewers, CI requirements, secret-scanning expectations, and release-critical paths. The migration test should verify that the replacement model does not normalize unsafe repository behavior, such as editing generated files instead of source files, weakening tests to pass, broadening permissions, or turning a review suggestion into an unauthorized write.

Define Baselines Before Comparing GPT-5.6 Sol, GPT-6 Astra, or Any Other Candidate

A baseline is the evidence package that describes acceptable behavior before the retirement forces a decision. It can include a GPT-5.5 output, but it should not define success as “the replacement says the same words.” Replacement models may use different reasoning styles, ask different clarifying questions, or produce better structured outputs. Define the business or engineering requirement independently: factual accuracy against named sources, correct format, safe boundaries, complete test coverage, acceptable review effort, and no unauthorized action.

Decision rule: set different thresholds by workflow criticality. A low-risk brainstorming workflow may pass if the replacement preserves usefulness and safety with minor style differences. A regulated reporting workflow should require source traceability, reviewer sign-off, and no unresolved policy exceptions. A production-code workflow should require maintainer review, tests appropriate to the change, and no merge or deployment without the normal engineering approval process.

Build a Representative Regression Suite Instead of Testing Only Favorite Prompts

The most common migration error is testing the prompt that already works and ignoring the edge cases that caused earlier incidents. A representative suite should include successful examples, borderline examples, failure examples, and adversarial or policy-bound examples. If the workflow is used by multiple departments, include prompts from each department because tone, terminology, data access, and approval expectations vary by function.

Sample prompt regression categories: summarization with required omissions; executive drafting with no unsupported metrics; policy interpretation with conflict handling; data analysis with source and date boundaries; customer-message drafting with human approval; code explanation without edits; patch generation with tests; and review comments that separate blockers from suggestions. Each test should state what a passing answer must do, what it must not do, and who can judge the result.

Regression test card

Workflow:
Replacement candidate:
Surface:
Owner:
Input data class:
Required sources:
Allowed tools:
Prohibited actions:
Expected output format:
Pass criteria:
Fail criteria:
Human reviewer:
Evidence location:
Decision: pass / conditional pass / fail / retest required
Notes on differences from GPT-5.5:

A conditional pass is useful only if it names the condition. “Works with edits” is too vague. “Passes if the system prompt is updated to require a source table and if finance approves the revised output format” is actionable. Conditional passes should have an owner and a retest date, otherwise they become undocumented production changes.

Capture Evidence That an Administrator, Auditor, or Maintainer Can Reconstruct

Evidence capture should allow a reviewer to reconstruct what was tested without exposing unnecessary sensitive data. For every migration decision, capture the surface, account or workspace context, date, replacement candidate, prompt or task description, tool permissions used, input data class, output, reviewer, pass/fail result, and unresolved risks. If the test uses sensitive content, store the full record only in the approved internal system and keep the migration register limited to metadata and redacted summaries.

Evidence warning: analytics can show activity patterns, but activity is not proof of quality, causation, productivity, or business value. A spike in replacement-model usage after the deadline may show that users adapted or had no alternative; it does not prove the replacement performs equally. Pair usage observations with regression results, reviewer notes, defect reports, rework, support tickets, and business-owner sign-off.

For Codex, preserve the branch or diff reference, the task prompt, the model candidate, the tests requested, the tests actually run, the human review result, and any changes made by the human after the model’s contribution. Do not treat generated lines, accepted suggestions, or passing tests as complete proof of safety. The maintainer’s judgment, security review where needed, and the normal release process remain mandatory.

Map Budgets, Limits, and Escalation Contacts Before the Cutover Week

The official retirement notice does not promise preserved pricing, limits, or usage behavior for replacements. Do not infer that a workflow using GPT-5.6 Sol or GPT-6 Astra will consume the same budget profile as GPT-5.5. Administrators should identify high-volume workflows, teams near budget ceilings, critical cutover windows, and owners authorized to pause or reprioritize usage if limits are reached.

Budget inventory fields: workspace or team budget owner, expected daily use, critical periods, optional versus mandatory workflows, replacement candidate, approval threshold for expanded use, and escalation path if usage blocks business operations. The goal is not to predict exact consumption without evidence; it is to prevent a migration test or post-deadline surge from surprising finance, administrators, or teams with hard delivery dates.

Owner contacts should include a primary and backup for each critical dependency. A model retirement creates calendar risk: the only person who understands a prompt, repository, plugin, or Work task may be unavailable during the final week. For high-risk workflows, require a named business owner, technical owner, security contact, and final approver. If no one can approve a migration decision, the workflow should not be treated as production-ready.

Use a Cutover Board with Explicit Status Labels

A cutover board prevents ambiguous phrases such as “mostly moved” or “probably fine.” Use status labels that force evidence: not inventoried, inventoried but untested, testing in progress, failed replacement test, conditional pass, approved for replacement, retired with no replacement, and blocked by availability or policy. The last category is important because the official notice does not guarantee every replacement is available in every workspace or configuration.

Recommended weekly operating rhythm before October 14: administrators export or compile the dependency register, owners update test status, security reviews high-risk tools and repositories, finance reviews budget-sensitive workflows, and business owners approve or retire workflows. During the final week, freeze nonessential prompt changes for critical workflows so test evidence remains meaningful. If a prompt is still changing daily, any pass result should be treated as provisional.

The practical outcome of this section is a controlled decision: each GPT-5.5 dependency is either replaced with tested evidence, retired deliberately, blocked with a named issue, or escalated before the deadline. That is more reliable than assuming automatic continuity and discovering on October 14 that a key chat, Work task, Codex project, tool workflow, or budget owner was never part of the migration plan.

Cutover Operating Model: Pilot, Dual-Run, Rollout, Fallback, and Incident Boundaries

The safest way to treat the October 14 GPT-5.5 retirement is as a product-surface cutover with a hard date, not as a casual model preference change. OpenAI’s official @ChatGPT post states that GPT-5.5 will be retired on October 14, 2026 in ChatGPT, ChatGPT Work, and Codex across all plans, and it specifically tells Codex users to switch from GPT-5.5 to GPT-5.6 Sol or GPT-6 Astra. That statement is enough to justify an organized migration plan for users, administrators, and engineering teams, but it is not enough to assume prompt parity, tool parity, limit parity, automatic migration, or replacement availability in every workspace.

The operating model below separates the work into pilot, dual-run, rollout, fallback, rollback, communication, support, access-policy, capacity, and incident boundaries. The purpose is to keep teams from discovering on October 14 that a saved prompt, Work task, Codex workflow, repository operation, plugin path, or approval process depended on GPT-5.5 behavior that was never formally tested against the replacement model. Treat each boundary as a control point: if a team cannot name the owner, evidence, decision rule, and escalation path, the cutover is not ready.

Pilot Boundary: Test Representative Work, Not Just Convenient Prompts

A pilot should answer one question: can the replacement model complete the organization’s important GPT-5.5-dependent work with acceptable quality, safety, cost awareness, and review effort under the same governance constraints? A pilot is not a demo, a single “looks good” chat, or a side-by-side comparison of only the cleanest prompts. For ChatGPT and ChatGPT Work, include recurring knowledge-worker tasks such as drafting, analysis, summarization, policy interpretation, customer-response preparation, and document transformation. For Codex, include code navigation, patch generation, review assistance, test-writing, repository explanation, refactoring proposals, and failure analysis.

For Codex users, OpenAI’s post gives the only explicit replacement guidance in the notice: switch from GPT-5.5 to GPT-5.6 Sol or GPT-6 Astra. That guidance should be handled as a candidate-selection instruction rather than a guarantee that either model preserves the exact coding behavior, tool behavior, latency profile, output style, or repository-level judgment of GPT-5.5. A practical pilot should run both candidates where access allows, compare their outputs against the same task set, and record which candidate is approved for which class of work.

This article provides a production migration guide from GPT-5.2 to GPT-5.5 with prompt compatibility testing, cost optimization, rollback strategies, and API transition planning. The How to Migrate from GPT-5.2 to GPT-5.5 in Production: Complete API Transition Guide with Prompt Compatibility Testing, Cost Optimization, and Rollback Strategies article is a focused companion for Prompt Regression Testing because prompt regression testing in a model retirement article needs a migration-focused testing reference, and this target explicitly covers prompt compatibility testing during production migration.

Recommended pilot rule: a task should not pass the pilot merely because the final answer appears plausible. Require the reviewer to record whether the model used the correct source material, respected the requested format, preserved constraints, avoided unauthorized assumptions, handled ambiguity safely, and produced work that would require no more than the team’s accepted review effort. In engineering pilots, require evidence from tests, diffs, review comments, or maintainer judgment; do not treat generated code volume or apparent confidence as proof of correctness.

Dual-Run Boundary: Compare Results Without Doubling Risk

A dual-run is the period in which users compare GPT-5.5-dependent workflows with one or more replacement candidates before the retirement date. The objective is not to ask two models to perform every task forever; it is to expose differences early enough to fix prompts, instructions, source handling, tool permissions, or model-selection rules. Dual-run candidates should be tested against stable inputs, documented prompts, and consistent review criteria, otherwise teams will confuse input drift with model behavior.

Recommended dual-run procedure: select a fixed test set, run the same task through GPT-5.5 where still available and the replacement candidate, blind-review outputs where feasible, and record the practical delta. For business writing, measure whether the output is correct, complete, policy-safe, and ready for the intended audience. For analysis, confirm calculations, sources, time period, and limitations. For Codex, use repository tests, maintainer review, and a controlled branch or sandbox; do not allow the dual-run to push directly to production, change permissions, publish releases, send external messages, or merge code without normal approval.

The dual-run must also protect confidential content. Teams should not copy unnecessary customer records, secrets, personal identifiers, privileged legal material, HR records, account data, or health information into comparison prompts. Use representative redacted inputs, approved internal test data, or already-authorized workspace sources. If a task cannot be tested without sensitive production data, record that as a security-review dependency rather than bypassing data-minimization rules.

Proposed dual-run record

Task name:
Business owner:
Surface: ChatGPT / ChatGPT Work / Codex
Current GPT-5.5 dependency:
Replacement candidate tested:
Prompt or workflow version:
Input data classification:
Tools, plugins, repositories, or sources used:
Human reviewer:
Result: pass / pass with changes / fail / not tested
Required prompt changes:
Required access-policy changes:
Required training or support notes:
Fallback if replacement is not ready:
Decision date:

Rollout Boundary: Use Staged Adoption Instead of One Workspace-Wide Surprise

A staged rollout reduces operational shock by moving from controlled testers to broader teams only after evidence supports the change. The first group should include owners of high-value workflows and maintainers of Codex-heavy repositories, not only enthusiastic volunteers. The second group should include adjacent users who can reveal training gaps, workspace-policy mismatches, or task types missed by the pilot. The final group should receive a clear model-selection instruction, a support path, and examples of revised prompts or Codex workflows.

This article is a setup guide for ChatGPT Enterprise covering the admin console, SSO, data controls, and model access management for teams. The How to Set Up ChatGPT Enterprise for Your Team: Admin Console, SSO, Data Controls, and Model Access Management article is a focused companion for Workspace Model Controls because it directly supports discussion of workspace-level model controls because it addresses enterprise administration and model access management.

Workspace administrators should verify the current model picker, workspace policy, and plan availability before announcing a replacement path. OpenAI’s official notice says GPT-5.5 retirement applies in ChatGPT, ChatGPT Work, and Codex across all plans, but it does not state that every replacement model is available in every workspace at the same time or under every policy configuration. If a team tells users “switch to GPT-6 Astra” but the model is not visible under that workspace’s controls, the rollout will become a support incident rather than a migration.

Recommended rollout gate: do not move a group to the replacement default until the owner can show approved model access, completed pilot tasks, known limitations, training notes, fallback instructions, and a support channel. If any of those elements is missing, the group may continue testing but should not be told that migration is complete. This distinction matters because an unready rollout creates silent failure: users may keep working, but with lower-quality results, hidden manual rework, or unauthorized workarounds.

Fallback Boundary: Define What Users Do When the Preferred Replacement Fails

A fallback is the safe next action when the selected replacement model is unavailable, unsuitable for a task, blocked by policy, or producing unacceptable results. Fallback is not the same as rollback. Because GPT-5.5 is being retired in the named product surfaces on October 14, teams should not design a post-deadline fallback that assumes users can simply return to GPT-5.5 inside ChatGPT, ChatGPT Work, or Codex. The realistic fallback may be another approved model, a manual process, a narrower prompt, a different tool path, or escalation to a specialist.

Codex teams should define fallback at the workflow level. If GPT-5.6 Sol is the approved replacement for routine patch generation but fails on a complex refactor, the fallback might be GPT-6 Astra, a human-authored design note, or a maintainer-led decomposition into smaller tasks. If GPT-6 Astra is preferred for repository reasoning but unavailable under a workspace rule, the fallback might be GPT-5.6 Sol for explanation-only work with a ban on direct patch generation until the model-access issue is resolved. The important rule is that fallback actions must stay inside approved access, repository, and human-review boundaries.

Rollback Boundary: Preserve the Ability to Undo Your Own Changes

Rollback planning is still necessary even when the retired model cannot be restored after the deadline. In this context, rollback means undoing the organization’s migration changes that caused harm: revised prompts, saved instructions, automation settings, tool access, training guidance, repository workflow changes, or documentation that pointed users to the wrong replacement. A team that cannot roll back its own configuration changes will compound model-migration risk with change-management risk.

Recommended rollback scope: store the previous version of every prompt template, saved instruction set, Codex workflow note, repository guide, plugin instruction, and user-facing migration announcement before changing it. Keep the owner, approval date, and reason for change with each version. If a new instruction causes worse output, the team should be able to restore the earlier instruction, choose a different replacement model, or narrow the task scope without waiting for a broad workspace fix.

Rollback evidence should be understandable to an administrator or incident reviewer who was not present during testing. Screenshots alone are usually weak evidence because they can omit prompt text, policy state, source context, and reviewer judgment. A better record includes the task purpose, prompt version, selected model, surface, tools used, output sample, reviewer decision, and exact mitigation. For Codex, preserve repository context such as branch, commit reference, test command description, and review outcome without exposing secrets or unnecessary proprietary details in broad communications.

Communication Boundary: Tell Each Audience Only What It Can Act On

Users need clear instructions, not a full internal risk register. A knowledge worker should know when GPT-5.5 retires, what model to select if a replacement is visible, which tasks require extra review, and where to report poor results. A Codex user should know whether GPT-5.6 Sol, GPT-6 Astra, or another approved model is preferred for each repository workflow. An administrator should know which groups are affected, which workspace controls must be verified, and which support queues may see increased volume. Executives should know the operational risk, readiness status, and unresolved decisions without being given unsupported claims about productivity or quality.

Recommended communication rule: distinguish official facts from local decisions. The official fact is that OpenAI’s @ChatGPT notice names October 14, 2026 for GPT-5.5 retirement in ChatGPT, ChatGPT Work, and Codex across all plans, and names GPT-5.6 Sol or GPT-6 Astra as Codex replacement options. A local decision is which replacement your workspace approves, which tasks have passed testing, which users migrate first, and what fallback applies when a task fails. Mixing these categories makes later incident review harder because teams cannot tell whether a failed assumption came from OpenAI’s notice or from an internal rollout decision.

Sample user notice

GPT-5.5 is scheduled to retire in ChatGPT, ChatGPT Work, and Codex on October 14, 2026. Our workspace is testing approved replacement models now.

What you should do:
1. Do not start new critical workflows that depend on GPT-5.5 without notifying the workflow owner.
2. Use the approved replacement listed for your team when it is available in your workspace.
3. Review outputs carefully, especially customer-facing, legal, finance, HR, security, code, and data-analysis work.
4. Report missing model access, degraded output quality, or tool behavior changes through the migration support channel.
5. Do not move confidential work to a personal account or another workspace to bypass model availability or policy.

Support, Capacity, and Access-Policy Boundaries

Support teams should expect three types of tickets: missing access, changed behavior, and uncertainty about which model to use. Missing access tickets belong first to workspace policy and plan verification, not to prompt engineering. Changed behavior tickets need a reproducible task record, not a general complaint that the new model “feels different.” Model-selection uncertainty should be answered with a task-specific decision table, because Codex patch generation, legal-draft preparation, data analysis, and general brainstorming may not share the same approved replacement path.

Capacity planning should assume the cutover week will create concentrated demand for testing, admin questions, repository reviews, and prompt repairs. The official post does not promise preserved limits, pricing parity, or capacity equivalence for replacement models. Organizations should therefore avoid scheduling the entire migration for the final business day before October 14. If teams rely on peak usage periods, month-end reporting, release trains, or customer-support surges, run the migration tests before those windows or define manual fallback procedures.

Access-policy boundaries are especially important in ChatGPT Work and Codex because users may have different workspace settings, roles, repositories, plugins, and administrative controls. A successful test by one user does not prove availability for another group. Administrators should verify model visibility and tool access by role or group, and they should avoid widening permissions simply to make a replacement path look smoother. If a replacement model needs different access to complete a workflow, that is a governance decision requiring review, not a routine migration tweak.

API Boundary: Do Not Convert Product Silence into an API Promise

The September 15 official @ChatGPT post did not announce an API retirement for GPT-5.5. It named ChatGPT, ChatGPT Work, and Codex as the affected product surfaces, stated that the retirement applies across all plans, and gave Codex replacement guidance. That absence matters because product-surface retirement and API deprecation are not the same operational event. However, silence in that post is not a permanence guarantee for API users, and teams must not treat the lack of an API deadline in the post as proof that an API model will remain available indefinitely.

Developers and platform owners should verify current API deprecation notices, model documentation, account notices, changelogs, and any provider communications that govern their API usage at implementation time. If an application references GPT-5.5 through an API, the correct action is to inspect the current API-facing source of truth, run application-level evaluations against approved replacement models, and prepare a separate API migration plan if deprecation is announced. Do not copy the October 14 product-surface deadline into an API runbook unless an official API notice says so, and do not omit API contingency planning merely because the product post did not mention it.

Recommended API boundary rule: maintain separate registers for product-surface dependencies and API dependencies. The product register should cover ChatGPT, ChatGPT Work, Codex, conversations, tasks, prompts, workspace controls, plugins, skills, and repository workflows. The API register should cover model identifiers used in code, configuration, routing layers, eval suites, fallback logic, rate and budget controls, client libraries, deployment pipelines, and customer-facing commitments. These registers can share evaluation assets, but they should not share unverified assumptions about deadlines or availability.

Incident Boundary: Decide in Advance What Triggers a Stop

An incident boundary defines when the migration stops, escalates, or reverts local changes. Without a prewritten boundary, users may normalize degraded output, continue unsafe workarounds, or flood support with unactionable reports. Incidents should be classified by impact: blocked access, severe output regression, unauthorized data exposure, tool misuse, code-quality failure, external-message risk, billing or capacity concern, or policy mismatch. Each class should have an owner and a required evidence packet.

Recommended stop conditions: pause a workflow if the replacement model produces materially incorrect output for a high-risk task, attempts or suggests unauthorized access, causes a tool or plugin to operate outside approved intent, generates a Codex patch that repeatedly changes unrelated files, or encourages users to bypass workspace controls. Human approval remains mandatory for external messages, writes, payments, destructive operations, permission changes, publication, production deployment, and other consequential actions. The migration should never be used as a reason to weaken review gates.

Incident response should also protect evidence and confidentiality. Ask reporters for the minimum necessary prompt, output, model, surface, tool context, and business impact. Do not request credentials, tokens, secrets, account numbers, sensitive personal data, or entire repositories when a smaller reproducible excerpt will suffice. If a Codex issue involves a sensitive diff, route it through the organization’s approved secure review path rather than pasting proprietary code into a broad support channel.

Decision Checklist for the Week Before October 14

1. Confirm official scope: record that the GPT-5.5 retirement notice applies to ChatGPT, ChatGPT Work, and Codex across all plans, and that Codex users were told to switch to GPT-5.6 Sol or GPT-6 Astra.
2. Separate API assumptions: verify current API deprecation notices and model documentation instead of treating the product-surface notice as either an API deadline or a permanent API exemption.
3. Validate access: confirm that approved replacement models are visible to the right roles, groups, repositories, or workspaces under current policy.
4. Complete pilots: require representative task evidence for ChatGPT, ChatGPT Work, Codex, tools, plugins, and saved instructions that materially depend on GPT-5.5.
5. Run dual comparisons: compare replacement outputs against stable inputs and documented acceptance criteria before changing broad guidance.
6. Publish fallback rules: tell users what to do when the approved replacement is unavailable, unsuitable, or fails review.
7. Preserve rollback artifacts: keep previous prompt, instruction, workflow, and documentation versions so local migration changes can be undone.
8. Staff support: prepare for missing-access tickets, model-selection questions, degraded-output reports, and Codex review escalations.
9. Define incident stops: pause unsafe workflows quickly when output, access, tool use, or code behavior crosses a preapproved risk threshold.

The practical takeaway is conservative: migrate early, test with evidence, and keep product-surface facts separate from API assumptions. OpenAI has given a clear October 14 retirement date for GPT-5.5 in ChatGPT, ChatGPT Work, and Codex, plus explicit Codex replacement names, but it has not promised automatic continuity for prompts, tools, limits, workspace access, or API usage in that notice. Teams that document those boundaries now will spend the cutover week making decisions from evidence instead of reconstructing assumptions under pressure.

Date-Based Action Plan: From Inventory to the October 14 Retirement

The official @ChatGPT notice gives teams one fixed operational date: GPT-5.5 will be retired on October 14, 2026 in ChatGPT, ChatGPT Work, and Codex across all plans. Treat that date as a product-surface deadline, not as evidence of an API retirement, a grace period, a guaranteed automatic migration, or behavior parity with any replacement. The safest plan is to assume that any GPT-5.5-dependent chat habit, Work workflow, Codex task, saved instruction, prompt library, evaluation, tool path, or training material needs owner review before October 14.

Use the timeline as a minimum operating plan, not as a prediction of platform behavior. OpenAI’s notice does not say that existing conversations, Codex state, tasks, custom instructions, plugins, skills, tools, or saved workflows will automatically preserve behavior after October 14. If a workflow matters to a customer, production repository, regulated process, executive deliverable, security review, finance decision, HR action, or external message, test it before the deadline and require a qualified human to approve the result.

This Codex release-channel playbook explains stable-versus-alpha separation, canary repositories, permission boundaries, checkpoints, and rollback controls that teams can adapt when replacing a retiring model. The Codex Stable vs 0.154 Alpha Playbook: Release Channels, Canary Repositories, Permissions, Checkpoints, and Rollback article is a focused companion for Migration Rollback Planning because it is more directly about reversible rollout and rollback controls than the draft target’s broad migration overview.

RACI for a GPT-5.5 Product-Surface Cutover

A migration without named decision rights usually fails in the handoff between administrators, developers, workflow owners, and support teams. The RACI below assigns responsibility for evidence, not just activity. Adapt the roles to your organization, but do not leave model selection, permission changes, external communication, or production code paths without an accountable owner.

Keep the accountability line narrow for the final decision. A broad group can contribute evidence, but one named person or governance forum should decide whether each workflow is ready, deferred, disabled, or allowed only with manual review. That prevents teams from mistaking informal testing for approval.

Risk Register for October 14

The retirement creates operational risk even when the replacement model is technically available, because prompt behavior, tool use, latency perception, budget consumption, user training, and support assumptions can all change. The register below focuses on controls the organization can apply without assuming undocumented migration behavior from OpenAI.

Go/No-Go Checklist for October 11–13

The final readiness review should be evidence-based and short enough to complete. If the answer is unknown, mark it unknown; do not convert unknowns into assumptions because the deadline is close. A workflow can still proceed with manual restrictions, but those restrictions should be explicit and visible to users.

1. Official scope confirmed: The team has recorded that the notice covers ChatGPT, ChatGPT Work, and Codex across all plans, and has not asserted an API retirement unless supported by separate official API documentation.
2. Dependency inventory complete: Every known GPT-5.5-dependent workflow has an owner, impact rating, replacement candidate, and test status.
3. Codex replacements tested: GPT-5.6 Sol or GPT-6 Astra has been tested for Codex usage where available, with repository-specific acceptance criteria and human review gates.
4. Workspace availability verified: Administrators have checked model access from the relevant workspace, group, plan, and policy context.
5. Prompt changes approved: Saved prompts, instructions, templates, and training material no longer direct users to GPT-5.5 unless they are archived as historical evidence.
6. Tool paths validated: Plugins, skills, repository tools, and connected actions have been tested with least-privilege accounts and clear approval gates.
7. Fallback path documented: Users know whether to pause, use a validated replacement, escalate to support, or switch to a manual process if a workflow fails.
8. Budget and limit watchpoints assigned: Owners know which usage, spend, latency, or capacity signals to watch, without treating them as standalone proof of success.
9. Support desk prepared: Support staff have triage language that distinguishes official facts, workspace-specific availability, and unresolved questions.
10. Consequential actions gated: External messages, code merges, deployments, payments, permission changes, publication, legal decisions, finance actions, HR decisions, and destructive operations require human approval.

A “go” decision should mean the workflow can operate under the documented controls, not that the replacement model is identical to GPT-5.5. A “no-go” decision should name the temporary operating mode: pause the workflow, keep it manual, route it to a validated alternative, or allow limited use only with enhanced review.

Rollback Evidence Packet

Rollback planning is not a promise that GPT-5.5 will remain selectable after October 14. In this context, rollback means the organization can undo its own prompt edits, policy changes, documentation changes, automation changes, repository instruction changes, and rollout decisions if a replacement creates unacceptable risk. Preserve the packet before changing production-facing material.

Rollback evidence packet

1. Official-source record
   - Date and time the retirement notice was captured
   - Product surfaces named in the notice
   - Open questions not answered by the notice

2. Baseline workflow record
   - Workflow name and owner
   - Previous GPT-5.5 usage pattern
   - Prompt or instruction version before change
   - Tool, plugin, repository, or workspace dependencies

3. Replacement decision record
   - Candidate model or manual fallback
   - Reason for selection
   - Availability evidence from the affected workspace
   - Known differences and unresolved risks

4. Test evidence
   - Test inputs using approved data
   - Expected behavior
   - Actual behavior
   - Human evaluator notes
   - Failed or blocked cases

5. Change record
   - Prompt changes
   - Documentation changes
   - Workspace policy changes
   - Codex instruction changes
   - Communication sent to users

6. Reversal procedure
   - What can be reverted internally
   - Who may approve reversal
   - What cannot be restored if GPT-5.5 is no longer available
   - Manual process to use while defects are corrected

The most important line in the packet is the distinction between reversible internal changes and irreversible product availability. If GPT-5.5 is retired from the relevant product surface, a rollback cannot depend on reselecting it. Your practical fallback is a validated replacement, a manual process, a narrowed workflow, or a paused workflow until defects are resolved.

Post-Cutover Review After October 14

Schedule the first review within two business days of the cutover and a second review after enough representative work has run to expose edge cases. The first review should focus on access, user confusion, blocked workflows, tool failures, and support volume. The second review should focus on quality, review effort, rework, defects, budget signals, and whether replacement instructions need tightening.

The review should preserve failures, not hide them. A migration report that only lists successful examples is not useful for administrators, auditors, maintainers, or future incident responders. Record known limitations, edge cases, unresolved API questions, workspace-specific availability differences, and any workflow where the team chose manual review because replacement behavior was not yet proven.

Closing Guidance for the October 14 Deadline

The actionable fact is narrow but important: OpenAI’s official ChatGPT account says GPT-5.5 retires on October 14, 2026 in ChatGPT, ChatGPT Work, and Codex across all plans, and Codex users are directed to switch to GPT-5.6 Sol or GPT-6 Astra. Everything else that matters operationally—API status, workspace availability, prompt behavior, tool behavior, limits, pricing, continuity, and migration mechanics—must be verified against current official documentation and the affected workspace.

The safest teams will not wait for the deadline to discover hidden dependencies. They will inventory GPT-5.5 usage, test replacement candidates, preserve rollback evidence, communicate practical fallback paths, and require human approval for consequential work. That approach avoids two opposite mistakes: assuming nothing changes because the API was not named, or assuming everything migrates cleanly because a replacement was named for Codex.

Useful Links

• Official @ChatGPT GPT-5.5 retirement notice
• OpenAI model release notes
• OpenAI help: ChatGPT Work and Codex
• OpenAI model documentation