A safeguard that looks like a quality bug

Most API breaking changes announce themselves. A parameter is rejected, a field disappears, a request fails. This one does none of that. An application that trims old tool output to save tokens, rewrites its developer message mid-conversation, or summarizes early turns to stay inside a context window will keep working after it moves to GPT-6.2. It may work worse, and spend more doing it, because reasoning items the model produced earlier in the session are no longer in front of it. The removals are not invisible: a response can report them in its input_transformations field. But nothing fails, and an integration that does not log that field will not see them.

OpenAI is candid about the cost in its own guide: when the model loses access to reasoning items, "answer quality can decline and the model may use more tokens to repeat earlier work." The prefix guide adds that dropped reasoning can also increase latency, and that a prefix change cuts prompt-cache reuse from the edit point onward. Those are separate effects: lost cache reuse raises input cost on the turns that follow, and repeated reasoning raises it again if the model has to redo work. Neither is automatic. Both are priced in tokens.

The everyday version of the trap

The triggers are not exotic. An application that puts the current date, the current page, or any other changing value into its first message, and edits that message each turn, rewrites the start of the history on every turn, which puts every later reasoning item after an edit. Rotating tool definitions between turns does the same. So does the standard agent-framework move of replacing a long early exchange with a short summary once the context grows.

Two things do not trigger it, and they matter for the fix. Appending new items after a reasoning item is safe. Deleting whole items without editing the ones that remain is safe. The rule bites on edits and insertions before the item, not on growth or clean removal.

The append-only rewrite

OpenAI's recommended pattern is to treat the conversation as a log that only grows. Settings that used to change between requests now change by appending: a configuration_update item carries a new reasoning effort or a new output schema, an additional_tools item adds tools while the original tools array stays untouched, and updated instructions arrive as a new developer message at the end instead of an edit to the first one. Top-level instructions have also moved: from GPT-6.2 the API appends them after input and bills their tokens at the uncached input rate, so reusable instructions belong in a developer message at the start if they are to stay cacheable.

Compaction survives, but on OpenAI's terms. Its managed compaction, through /responses/compact or context_management, can replace earlier context and retain the reasoning items that follow, though the guide warns cache misses are difficult to avoid in those cases. For a summary an application writes itself, OpenAI recommends placing the compacted item at the end of the current context; insert it where the old turns were and the reasoning after that point is dropped.

How to find out if you are affected

There is a measuring instrument. Responses can carry an input_transformations field, which shows which reasoning items the API removed and why, and a removal can be matched by ID to the reasoning item in an earlier response. OpenAI's deployment checklist advises running a multi-turn task before deployment, logging the field whenever it is nonempty, fixing any prefix_mismatch it shows, and then tracking the percentage of production responses that show at least one. Prompt Cache Diagnostics can show where cache misses occur, on a best-effort basis; it cannot verify whether the model reused reasoning.

That is the honest way to read this change: not as a reason to avoid GPT-6.2, but as a migration cost that has to be counted. The safeguard itself is defensible. Reasoning produced against one history being silently reused against a different one is a real hazard, and binding the two together is a coherent answer. The cost is that the consequence lands in a migration guide and a diagnostics field, not at the point of use.

Sources

  1. [1] OpenAI, "Keep the prefix unchanged" (developer guide)Read source
  2. [2] OpenAI, "Using GPT-6.2" (developer guide)Read source
  3. [3] OpenAI, Reasoning guide (reasoning-item removal reasons)Read source
  4. [4] OpenAI, API deployment checklistRead source