gpt-5.5 Is Live in the API: 25-Day Migration Deadline and New Routing Math

OpenAI's SDK changelog quietly confirmed two things this week that demand immediate action: gpt-5.5 is now formally available on the API surface, and GPT-5.4 plus GPT-5.4 mini will be hard-removed from Codex for signed-in ChatGPT users on August 31, 2026 — 25 days from now. Miss that date and your Codex-based pipelines stop cold. No warning, no grace period retry.

This isn't academic. Any agentic coding workflow, any automated PR review loop, any internal copilot that strings together Codex calls on 5.4 is on a countdown timer. Let me tell you what actually matters here, because the surface-level story is "new model dropped" and the real story is about routing logic, cost model recalculation, and a compliance hook most teams haven't instrumented yet.

---

What Actually Shipped (The Non-Hype Version)

GPT-5.5 launched on April 23–24, 2026 and this week received formal API surface registration via OpenAI's SDK releases — Python SDK v2.52.0 and Node SDK v7.3.0 — meaning it's now a first-class model identifier you can route to in production. The model docs describe it as OpenAI's flagship for "the most complex professional work," with a 922K input / 128K output context window (effectively 1M+).

The most operationally interesting parameter: reasoning.effort, which accepts none, low, medium (default), high, and xhigh. This is a dial on the reasoning compute budget per call — and it changes everything about how you should be pricing and routing.

Pricing per OpenRouter's live listing: $5 / $30 per 1M tokens (input/output). That's higher than GPT-5.4 sticker price. But OpenAI's own claim is that 5.5 is "both more intelligent and much more token efficient," delivering better results with fewer tokens for most Codex use cases. Directionally, for long-context or multi-step agentic tasks where 5.4 was verbose, the actual cost delta is likely smaller than the rate card suggests — but you need to measure this for your specific workloads, not assume it.

Also confirmed in the same SDK release: content provenance checks — API-level support for verifying the authenticity and origin of AI-generated content. I'll come back to why this matters for enterprise builders.

---

The Deprecation Calculus: Two Clocks Running

You're not dealing with one deadline, you're dealing with two:

Model	Deprecation Event	Hard Date
GPT-5.4 (Codex)	Removed for ChatGPT signed-in users	August 31, 2026
GPT-5.4 mini (Codex)	Removed for ChatGPT signed-in users	August 31, 2026
OpenAI o3	Retired from ChatGPT	August 26, 2026

Sources: model release notes, SDK changelog.

If you're running Codex workflows via the API directly (not through ChatGPT's signed-in interface), the August 31 date may not immediately affect you — but that distinction is thin ice. The API deprecation cadence historically follows the product-facing deprecation by weeks, not months. Don't use that gap as a plan.

The more immediate concern: o3 sunsets August 26 after its 90-day window. If you have eval pipelines, grading agents, or any workflow that uses o3 as a judge model — that's five days earlier than the Codex cut-off, and a different migration path.

---

The reasoning.effort Parameter Is a Routing Primitive, Not a Tuning Knob

Most teams will treat reasoning.effort like a quality slider. That's the wrong frame. Treat it as a cost routing primitive — the same way you'd route between model tiers.

Here's the practical decision table:

code
Task Type                         → reasoning.effort recommendation
────────────────────────────────────────────────────────────────────
Simple extraction / classification → none or low
Code generation (well-defined)     → medium (default)
Complex debugging, architecture Q  → high
Frontier reasoning, novel problems → xhigh
Cost-sensitive batch processing    → low + output validation layer

The failure mode I see repeatedly in production agentic systems is defaulting to high or xhigh for all calls "to be safe" — then wondering why costs are spiking. For a multi-agent travel planning system (the kind I work on at Etera AI), there are easily 10-15 LLM calls per session. Most of them are structured extraction or tool dispatch — low effort is fine. Two or three calls — itinerary synthesis, constraint resolution — need medium or high. Running xhigh uniformly would degrade the economics badly.

The right architecture: instrument effort levels per call type, log actual token usage per effort tier, then tighten the budget over time as you build data. Don't guess.

---

The 1M-Token Context Window: Power You'll Misuse

A 922K input window is genuinely useful for a narrow set of tasks: full codebase review, long document analysis, large context RAG synthesis. For most agentic workloads, stuffing 500K tokens of context into every call is the fastest way to burn your budget and degrade response quality through context dilution.

The temptation is to use the large context as a substitute for good retrieval design — shove everything in and let the model sort it out. That approach degrades badly at scale. Large context windows reduce the pressure to build proper retrieval and chunking pipelines, and then you pay for it in both token costs and reasoning quality when the model has to attend across a huge noisy context.

If you're building RAG pipelines, the window is a fallback and a synthesis layer — not a replacement for retrieval precision.

---

Content Provenance Checks: Wire This Now, Before It's Contractual

The most underreported item in this SDK release is the addition of content provenance checks in Python SDK v2.52.0 and Node SDK v7.3.0 (source). This is API-level tooling to verify the authenticity and origin of AI-generated content.

Right now, this reads as a developer feature. In 12-18 months, for any team selling to regulated industries — finance, healthcare, legal, government procurement — this will be a contractual checkbox. The EU AI Act's transparency requirements are already in force for certain risk categories. Enterprise procurement teams are starting to ask "how do you attest that this output came from the model you claim?"

Instrumenting this while it's optional costs almost nothing. Retrofitting it after a procurement blocker or an audit finding is painful. Wire it in now, add it to your observability layer, and you have a differentiator in enterprise conversations.

If you're building AI products that will go through enterprise security review, this connects directly to the kind of technical evidence that gets scrutinized — see the broader pattern in AI due diligence processes.

---

The Migration Path: GPT-5.4 → GPT-5.5

For most teams, this is a model string swap. The friction is in validation, not implementation — the engineering takes days, the confidence-building takes longer. Here's what the migration actually involves:

1. Identify all 5.4 call sites. Grep your codebase for gpt-5.4 and gpt-5.4-mini. Catalog them by function: what's each call doing, what's the expected output format, what downstream systems consume it.

2. Set reasoning.effort explicitly. Don't rely on the default. Audit each call type against the table above and set effort levels intentionally.

3. Run parallel evals before you cut over. Run 5.4 and 5.5 side-by-side on a representative sample of your real inputs. Don't rely on benchmarks — they won't tell you how your specific prompts perform. Measure token usage, output quality (with your own grading criteria), and latency.

4. Use feature flags for the rollout. A/B the migration, not a hard cut-over. If 5.5 regresses on a specific task type, you want a rollback path in seconds, not a redeployment. This is a pattern worth building properly — feature flags for LLM changes is the right architecture here.

5. Update your cost model. Your spend projections built on 5.4 pricing need recalculation against 5.5's $5/$30 rates, offset by OpenAI's claimed token efficiency gain. Don't assume the efficiency claim holds for your workload — measure it.

The timeline is tight but tractable. The engineering work is days. The thing that will slow you down is getting stakeholder sign-off on eval criteria and waiting for enough production traffic to build confidence. Don't let the process start later than today.

---

The One Thing OpenAI Won't Tell You Directly

The deprecation cadence is accelerating. GPT-5.4 launched, peaked, and is being deprecated in a window that's shorter than the software development cycles at most companies. If your model pinning strategy is "we'll migrate when we have to," you are permanently in reactive mode — paying engineering tax every few months just to stand still.

The durable play is to abstract your model routing layer so that swapping model identifiers doesn't touch business logic. One config change, a feature flag, and an eval run. That's the architecture worth building, and every deprecation cycle is the reason to do it.

Model velocity is the new dependency management problem. Treat it like one.

---

What to Actually Do

1. Grep today. Find every gpt-5.4 and gpt-5.4-mini reference in your codebase. You have 25 days — start the audit now, not next week.

2. Set explicit reasoning.effort values for every GPT-5.5 call you introduce. Default is medium; make sure that's right for each call type before it hits production at scale.

3. Run a 200-sample parallel eval of 5.4 vs 5.5 on your real workload before cutting over. Pay specific attention to token counts — if 5.5 is genuinely more efficient for your use case, your cost model just improved.

4. Wire content provenance checks into your observability pipeline this sprint. It's optional now; it won't always be.

5. Add o3's August 26 sunset to your sprint board right now if any of your eval pipelines or judge models use it — that deadline lands five days before the Codex cut-off and will sneak up on you.

The deprecation isn't the problem. The problem is teams that treat model migrations as low-priority maintenance tasks. At the pace OpenAI is moving, that attitude is the single fastest way to accumulate engineering debt that stalls actual product work.