GPT-5.5 Retires October 14: A Migration Checklist That Leaves No Landmines

When a model retires, the dangerous part is never the model; it is the fingerprints it left across your systems. OpenAI has confirmed that GPT-5.5 retires from ChatGPT, ChatGPT Work, and Codex on October 14, 2026, across consumer, Business, Enterprise, and Edu plans. The official documentation includes two crucial sentences: this retirement does not apply to the OpenAI API, and if you use Codex with ChatGPT sign-in, switch to GPT-5.6 Sol (gpt-5.6-sol) before October 14.

"A model retirement tests discipline, not skill"

1. What Actually Disappears, and What Does Not

Draw the boundary first; it removes half the panic. What disappears is GPT-5.5 availability inside three products: ChatGPT, ChatGPT Work, and Codex. Ordinary users will barely notice, since conversations move smoothly to the new default model. What does not disappear is the API: the documentation states plainly that the retirement does not apply to the OpenAI API, so anything calling the API directly is unaffected. The real exposure sits with two groups: developers using Codex with ChatGPT sign-in, and anyone who wrote the string gpt-5.5 into a config file or a script. That asymmetry is the whole story. A retirement inside a product is a product decision on a product timeline, while the API keeps its contract unchanged. If your architecture already treats model choice as configuration, this is a two-line change. If it does not, it is a project.

# 1) Find every hardcoded reference, then split explicit from implicit.
#    Model names hide in configs, not just in source.
rg -n --hidden --no-ignore -g '!node_modules' -g '!.git'    'gpt-5.5|gpt-5-5|"gpt-5.5"' . | tee /tmp/model-refs.txt

grep -E '.(json|ya?ml|toml|env)$' /tmp/model-refs.txt   # config surface
grep -vE '.(json|ya?ml|toml|env)$' /tmp/model-refs.txt   # source surface

2. Where the Hardcoded Name Hides: Six Common Corners

The official guidance is specific: replace GPT-5.5 in workspace defaults, saved model settings, managed configurations, custom agents, scheduled tasks, and scripts. The list is long because model names survive in many forms. Sometimes it is an explicit string, sometimes a saved mode in a dropdown, sometimes an implicit default inside a custom GPT. The practical approach is a string sweep across repositories and configuration surfaces first, then split findings into explicit references, which can be replaced mechanically, and implicit dependencies, which each need a run to confirm.

# 2) One source of truth. Retired names should be unrepresentable.
RETIRED = {"gpt-5.5", "gpt-5.5-turbo"}

MODELS = {
    "chat_default": "gpt-5.6-sol",     # was gpt-5.5 for Codex sign-in users
    "codex_signin": "gpt-5.6-sol",
    "heavy": "gpt-6-astra",
    "cheap": "gpt-6-mini",
}

def model(key: str) -> str:
    name = MODELS[key]
    if name in RETIRED:
        raise ValueError(f"retired model selected: {name}")
    return name

print(model("codex_signin"))

3. The Codex Fork in the Road

Codex users need to know how they authenticate. If you sign in with ChatGPT, switch to gpt-5.6-sol before October 14. If you use an API key you are not affected by this retirement, but you still should not stay on the older model, because the version gap shows up on long tasks. When you switch, do not change a single dropdown: walk through CI scripts in the repository, local configuration, and shared team templates. The most common failure is fixing it locally while CI keeps running the old model, so one person is migrated and the pipeline is not. One practical trick: make the authentication path visible in your logs. If you cannot tell from a run whether it authenticated with ChatGPT sign-in or an API key, you cannot tell whether the retirement touches it, and you will end up migrating the same thing twice.

// 3) Shadow pass: same requests, two models, three metrics that matter.
async function shadow(requests, oldModel, newModel) {
  const results = { parse: [0, 0], tools: [0, 0], evals: [0, 0] };
  for (const req of requests) {
    const [a, b] = await Promise.all([
      call(oldModel, req), call(newModel, req),
    ]);
    results.parse[0] += a.parsed ? 1 : 0;   results.parse[1] += b.parsed ? 1 : 0;
    results.tools[0] += a.toolArgsOk ? 1 : 0; results.tools[1] += b.toolArgsOk ? 1 : 0;
    results.evals[0] += a.passed ? 1 : 0;   results.evals[1] += b.passed ? 1 : 0;
  }
  return results;   // decide with numbers, not vibes
}

4. Do Not Switch Blind: Run a Shadow Pass First

The most expensive mistake in a model migration is switching outright and waiting for complaints. The safer pattern is dual-run: send the same batch of real requests to both models and compare outputs. The question is not which one is "better" but three metrics: parse success rate on structured output, argument correctness on tool calls, and your eval suite pass rate. If parse success drops, your prompts relied on a formatting habit of the old model. If tool arguments get worse, you need more few-shot examples. All of this belongs before October 14.

# 4) A CI guard so a retired identifier can never ship again.
import pathlib, re, sys

RETIRED = re.compile(r"gpt-5.[45](-turbo)?")

def scan(root=".", allow=("docs/", "CHANGELOG.md")):
    bad = []
    for p in pathlib.Path(root).rglob("*"):
        if not p.is_file() or "node_modules" in p.parts:
            continue
        if any(str(p).startswith(a) for a in allow):
            continue
        try:
            text = p.read_text(encoding="utf-8", errors="ignore")
        except OSError:
            continue
        for i, line in enumerate(text.splitlines(), 1):
            if RETIRED.search(line):
                bad.append(f"{p}:{i}")
    return bad

problems = scan()
if problems:
    print("retired model identifier found:")
    print("
".join(problems)); sys.exit(1)

5. Prompts Drift, and It Is Not Mysticism

The same prompt behaving differently on a new model is normal: instruction-following tendencies, format preferences, and default output length can all shift. The answer is not to rewrite everything. Treat it as a minor version upgrade: use your eval suite to find which prompts are affected, then add targeted constraints, such as an explicit JSON schema, worked examples, or a length limit. A useful heuristic when triaging which prompts broke: the ones that fail usually rely on implicit format conventions rather than explicit schemas. Constraints you wrote down survive; habits you picked up do not. Once that is done, wire the eval suite into CI, so the next model change is a single run instead of another archaeology project. Two small implementation notes make the shadow pass cheaper. Cache the responses so a rerun does not pay twice, and store the diff per request rather than per batch, so you can inspect the ten worst cases instead of a single summary number.

// 5) Rollback in one switch. A migration without an exit is a gamble.
const MIGRATED = process.env.MODEL_MIGRATED === "1";

const ROUTES = {
  migrated: { chat: "gpt-5.6-sol", heavy: "gpt-6-astra" },
  legacy:   { chat: "gpt-5.5",     heavy: "gpt-5.5" },   // API-only fallback
};

export function pick(kind) {
  const table = MIGRATED ? ROUTES.migrated : ROUTES.legacy;
  return table[kind];
}

// Flip MODEL_MIGRATED=0 in the environment to roll back in seconds.
console.log("chat model:", pick("chat"));

6. The Migration Checklist and the Rollback

Five rules. First, centralize the model name into one constant or config key so the literal appears nowhere else. Second, sweep repositories and configuration surfaces and treat explicit references separately from implicit dependencies. Third, dual-run and decide on three metrics: parse rate, tool-argument correctness, and eval pass rate. Fourth, add a CI guard that fails on retired model identifiers. Fifth, keep a rollback switch that flips within thirty seconds. October 14 is not a technical challenge; it is a discipline test. Teams with less hardcoding and better evals will feel the change less. And schedule the work now rather than on October 13. The date is known, the model is known, and the only variable left is how many places your team hardcoded a string.