A generated title card reading 'GPT-6.2 Preserved Reasoning: Edit the Prefix, Pay Twice', subtitled around reasoning items being bound to the conversation history in front of them, above three numbered rows: that the binding starts with GPT-6.2 Astra and GPT-6.2 Sol; that four ordinary prefix edits drop the items; and that the affected span bills $2.00 per million input tokens instead of $0.10.
Guides & Insights

GPT-6.2 Preserved Reasoning: Edit the Prefix, Pay Twice

Author

Elias Hawthorne

Date Published

Latest models · 20View all models →
Benchmarks: Artificial Analysis · updated daily
Back to all posts

On 17 November 2026, O​penAI shipped GPT-6.2 Astra and GPT-6.2 Sol with a change to the Responses API that has nothing to do with model quality and everything to do with how much you pay for it. Starting with these two models, a reasoning item is bound to the conversation history in front of it. Edit anything earlier in the transcript — shorten a tool result, rewrite a developer message, swap a summary in for three old turns — and the API drops the reasoning items that followed, as a safeguard. The model then has to redo work it had already done. There is no error, no warning at request time, and no line item. There is a slightly worse answer and a larger invoice, and the two are hard to connect.

This is not a deprecation you can schedule. It is a behaviour that is already live for anyone calling gpt-6.2-astra or gpt-6.2-sol today, and it will reach every team that upgrades, which is why it deserves to be read as a migration item rather than a footnote in a changelog.

What actually changed in the Responses API

Earlier models kept their reasoning items across a prefix edit. You could rewrite a developer message between turns, or replace the first ten exchanges with a summary, and the reasoning the model had produced would stay in context. That was forgiving in exactly the way agent code is careless: whatever you sent, the model got the benefit of its earlier thinking.

Under the new behaviour the API inspects the history, and when it detects that the prefix in front of a reasoning item has changed, it removes that item. O​penAI's own documentation describes the consequence in plain terms — the model "may need to redo some reasoning," which "can increase token usage, cost, and latency," and answer quality can decline "if the model can't recover the lost reasoning."

The four triggers O​penAI lists are worth committing to memory, because three of them look like tidy code rather than like a behaviour change:

• Editing earlier input items — trimming a tool result, deleting a turn, or replacing a block of history with a summary.

• Changing tools — adding, removing or reordering a tool definition mid-conversation.

• Changing text.format — swapping an output schema partway through a session.

• Changing reasoning.effort — turning the dial down for a cheap follow-up turn, which is the single most common cost optimisation in an agent loop.

Note what is not on the list. Appending new content after a reasoning item is fine. Deleting whole items is fine. The rule is directional: the API looks backwards from each reasoning item, and anything that moved in front of it invalidates it.

A prefix edit is four ordinary code changes

Every one of those four triggers is something a competent engineer does on purpose. That is the problem. A prefix edit is not a mistake you make once; it is a design pattern you adopt because it is correct in every other respect.

The context truncation case is the clearest. A long-running agent fills its window, so you drop the oldest turns or summarise them. That is good hygiene, it saves input tokens, and on GPT-6 Sol it was free. On GPT-6.2 it deletes the reasoning that came after those turns, and the model starts the next step having forgotten why it chose the tool it chose.

The effort-dial case is worse, because it is a cost control that inverts. The natural optimisation — run routine turns at low and escalate to high when the work gets hard — is a change to reasoning.effort between requests. On GPT-6.2 that edit drops the reasoning, so the expensive escalation re-derives the expensive reasoning from scratch. You paid for high and you got high starting cold, which is a different and more expensive thing.

What a dropped reasoning item costs

There is no published price for a dropped reasoning item, so the honest way to size it is to look at what reasoning costs in the first place. Artificial Analysis measures the whole suite, and the per-task token counts are the closest thing to a public measurement of how much thinking a frontier model does on hard work.

On Intelligence Index v5.0.1 at max effort, GPT-6.2 Sol generates 60.9M output tokens to complete the nine-evaluation suite, against a weighted cost of $1.01 per index task and 9.3 minutes per task. GPT-6.2 Astra generates 65.8M output tokens for the same suite and bills $4.00 per index task at $40 per million output tokens. Those totals are the floor of what a full evaluation costs, and every one of those tokens was bought at the full output rate. Vendor-reported figures point the same way — O​penAI says GPT-6.2 Astra uses 22% fewer output tokens than GPT-6 Astra on its internal GDPval v2 benchmark — but that is a comparison between models, not a measurement of what a dropped item adds back.

The mechanism is what matters here, not the exact multiplier. A reasoning item that has to be regenerated is output tokens you already paid for, produced a second time. In an agent loop that runs twenty turns over one task, losing reasoning at turn six does not cost you one turn's worth of thinking; it costs you the re-derivation plus whatever degraded decisions followed from the thinner context. Both are invisible in a per-request log.

A generated single-column scoreboard with six rows. Cached input $0.10 per million tokens; uncached input $2.00 per million tokens; cost ratio on the affected span 20x; documented triggers 4; reasoning after a prefix edit: dropped; diagnostic field comparison_response_id. A footer line attributes the behaviour to OpenAI's preserved-reasoning guide and the cache rates to the GPT-6.2 Sol model page, 17 November 2026.

The append-only rewrite, in five moves

O​penAI's guidance is to stop editing the prefix and start appending to it. That is easy to say and it changes five separate call sites, so here they are together, with the exact field names.

• Reasoning effort — do not change reasoning.effort between requests. Append a configuration_update item to input instead, carrying the new effort. The documented shape is {"type": "configuration_update", "reasoning": {"effort": "high"}}, placed before the next user message. The setting persists until another update overrides it, and you can change reasoning.effort and text.format in the same item.

• Output schema — same item, same treatment. Change text.format through a configuration_update rather than by editing the request. Updating only one of the two leaves the other where it was, which is a subtle way to get an unexpected schema.

• Tools — add tools with an additional_tools item sent under the developer role, carrying a tools array, replayed in its original position. Keep existing definitions in their original order, and use tool_choice with allowed_tools to restrict what the model may call.

• Instructions — put reusable text in the first developer message inside input, not in the top-level instructions field. To change it, append a new developer message. On GPT-6.2 and later the top-level instructions field is appended after input, so editing it is itself a prefix change.

• Compaction — with O​penAI's own compaction, either the /responses/compact endpoint or context_management, reasoning survives the prefix change. Omit instructions when calling /responses/compact. With custom compaction, put the compacted item at the end of context. Note the sharp edge: automatic truncation and /responses/compact both reject histories that contain configuration_update items, so a session that uses the new pattern cannot be compacted by the old path.

If you compact manually with a compaction_trigger item, add a fresh configuration_update after the compaction and restate every setting you changed. Nothing carries across the boundary for you.

Detecting it before your invoice does

The reason this behaviour change is dangerous is that it fails quietly. The API returns 200. The response looks normal. What you need is a way to see the drop, and O​penAI ships one: set prompt_cache_options.comparison_response_id to an earlier response ID, then read the diagnostic reason and the cached token count. The input_transformations field lists which reasoning items were removed and why, and a prefix_mismatch reason matches by id to a reasoning item in the earlier response's output.

Two honest limits on that diagnostic. It reports the first difference on a best-effort basis, and it cannot verify whether the model actually reused the reasoning it kept. So treat it as a smoke detector, not a meter — it tells you a drop happened, not what it cost.

The other half of the instrumentation is the cache, and this is where the token story and the cost story meet. Prompt caching matches requests from the beginning, so a prefix edit does not just drop reasoning items; it ends cache reuse from the point of the edit onward. Everything after that point bills at the uncached input rate. On GPT-6.2 Sol that is $2.00 per million instead of $0.10 — a twenty-fold difference on the affected span. On GPT-6.2 Astra it is $8.00 instead of $0.40, which is the same twenty-fold ratio on a card four times larger.

That is the number to watch, and it is the one a launch post will never headline: the cache miss is the bill, and the dropped reasoning is the quality regression, and both come from the same edit. Tokens for the top-level instructions field on GPT-6.2 and later are billed at the uncached input rate for exactly this reason — the field sits outside the cached prefix.

Screenshot of the Artificial Analysis page for GPT-6.2 Sol, showing an Intelligence Index of 57 at max effort, a weighted cost of $1.01 per index task, 9.3 minutes per task, 72 output tokens per second and 60.9M output tokens used across the nine-evaluation suite.

Where this leaves a 6.1 Sol deployment

None of this argues against moving. GPT-6.1 Sol scores 55 on Intelligence Index v5.0.1 at max effort and GPT-6.2 Sol scores 57, at $1.27 per index task against $1.01 and 24.9 minutes per task against 9.3 — a faster, cheaper, slightly smarter model on an unchanged rate card of $2 input, $0.10 cached and $10 output. The upgrade is real. What changed is that the upgrade now has a correctness precondition, and the precondition is that your conversation handling is append-only.

The cheapest way to answer that is a bill comparison rather than a score comparison: send a sliver of live traffic to gpt-6.2-sol with your existing append-only instrumentation switched on, and read the cached-token share on both arms after a day. OrcaRouter serves openai/gpt-6.1-sol at the vendor's list price with nothing added on top, and the per-request cache accounting comes through in the usage block, so the 6.1 side of that ledger needs no separate contract to read. Failover is what keeps the sliver from becoming an incident: any request the new route can't serve falls through to the model already answering. The half of this that has to be said plainly is that GPT-6.2 Sol is not on the catalogue here yet, so the 6.2 arm is called directly against O​penAI while the 6.1 arm is called against us.

What to watch next is narrower than it sounds. The behaviour is documented, the migration path is documented, and the diagnostics exist. What does not exist yet is a public measurement of what a dropped reasoning item costs in output tokens on a real long-horizon task, and until someone publishes one, every estimate of the damage is a model of the mechanism rather than a reading off a meter. If you are running agents at volume, you are better placed to produce that number than any benchmark is — and you will produce it whether or not you want to, which is the argument for instrumenting now.

Screenshot of OpenAI's preserved-reasoning guide, showing the section on configuration_update and additional_tools items, the list of changes that cause reasoning items to be dropped, and the append-only guidance for changing effort, tools and output schema mid-conversation.

Compared in this article3

Detected from this article · Benchmarks: Artificial Analysis · updated daily