Free guide
GPT-6.2 Drops Its Reasoning When You Edit Old Messages: How to Keep It
Every reasoning item is now tied to the conversation before it. Edit that history and the API drops the reasoning that follows. Here's how it works and how to keep it.

The short version
- A reasoning item's prefix is everything in the conversation before it. On GPT-6.2 and later, change that prefix and the API drops the reasoning after the change.
- Dropped reasoning can mean more tokens, more cost and more latency, and sometimes lower quality. Editing the prefix also cuts prompt cache reuse from that point.
- Append instead of editing: a new developer message for new instructions, a configuration_update item for reasoning effort, additional_tools for new tools. Check input_transformations for prefix_mismatch.
How it actually works
Think of the chat as a brick wall
Every message is a brick. The model's hidden reasoning is the mortar laid on top of the bricks it was built on. OpenAI's own wording: each reasoning item is now tied to the conversation history before it. The reasoning stays opaque: the API does not return its text, it just lets the model reuse it on later turns.
Adding bricks on top keeps everything
When you append new items after a reasoning item, nothing under it changes, so the model can build on earlier reasoning. OpenAI says this gives better results with fewer tokens and more cache hits. The prompt cache matches requests from the beginning, so an unchanged prefix stays eligible for cache reuse.
Swapping a low brick drops the reasoning above it
A prefix change modifies earlier history: shortening a tool result, rewriting a developer message, or replacing older turns with a summary. On GPT-6.2 and later the API removes the reasoning items that follow the change and reports it as prefix_mismatch. The model may have to redo some reasoning, which can increase token usage, cost and latency, and quality can drop if it can't recover. Deleting whole items without editing the rest, or appending after the reasoning item, does not by itself trigger prefix_mismatch.
Why OpenAI does it
OpenAI lists it with its safeguards against distillation. The API already removed reasoning when you switch model families, downgrade to a less capable model, or switch organizations or users. From GPT-6.2 a changed prefix or a changed safety_identifier also removes it.
How to set it up
1.Carry reasoning forward
Use previous_response_id, or if you manage history yourself, send the original input plus every output item from each response, in the original order, and append new items after them. That is what lets GPT-6.2 reuse earlier reasoning.
2.Check input_transformations on your responses
Each Responses API response can list the reasoning items the API removed and why. A prefix_mismatch reason means your code inserted or edited something before that reasoning item. Match the id to a reasoning item in an earlier response's output to find which edit caused it. Prompt Cache Diagnostics (prompt_cache_options.comparison_response_id) shows where cache misses start.
3.Append new instructions instead of editing the first one
Keep reusable instructions in the first developer message in input and never rewrite it mid-conversation. To change the rules, append a new developer message at the end. On GPT-6.2, top-level instructions are appended after input, so use them for guidance that only applies to the current request.
4.Change reasoning effort with configuration_update
Don't change reasoning.effort between requests. Leave the request-level setting the same and add this item before the next user message in input. It applies to the next response and the ones after it until another update overrides it.
{ "type": "configuration_update", "reasoning": { "effort": "high" } }5.Add tools by appending, not by editing the tools list
Keep existing tool definitions in order. To add a tool, append an additional_tools item with the developer role and a tools array, and replay it in its original position. To limit tools on a turn, use tool_choice with allowed_tools.
6.Shrink big outputs before the first send, or use OpenAI compaction
Trimming an old tool result, file or image later counts as a prefix change. Shorten long tool outputs and downsize images or files before the model sees them the first time. If the context gets too long, OpenAI compaction (/responses/compact or context_management) keeps the reasoning items that follow. With your own summarizer, put the compacted item at the end of the context, not before recent turns.
The fine print
- Applies to the Responses API starting with GPT-6.2 (OpenAI says 'our newest frontier models'). Changes to how the API handles prefix edits were listed in the Nov 17, 2026 changelog with GPT-6.2 Astra and Sol.
- Only reasoning items are dropped. Your visible messages stay in the conversation.
- OpenAI has not published a token-savings or cache-hit number for keeping the prefix. It says only that dropped reasoning can increase token usage, cost and latency.
- Other things that remove reasoning items: switching model families, moving to a less capable model, switching organizations or users, and on GPT-6.2 a different safety_identifier (including setting it on only one of the two requests). Moving to a more capable model in the same family keeps compatible reasoning if the other checks pass.
- Compaction always changes the prefix, so some cache misses are hard to avoid there. OpenAI's own compaction keeps the later reasoning items anyway.
FAQ
Why did GPT-6.2 lose its reasoning after I edited an earlier message?
On GPT-6.2 and later, each reasoning item is tied to the conversation history before it. When you edit that history, the Responses API drops the reasoning items that follow the change. The response's input_transformations field lists them with the reason prefix_mismatch.
What counts as a prefix change?
Any edit to history before a reasoning item: shortening a tool result, rewriting a developer message, replacing older turns with a summary, or changing request parameters like tools or text.format. Appending new items after the reasoning, or deleting whole items without editing the rest, does not by itself trigger prefix_mismatch.
How do I change instructions without breaking the prefix?
Append a new developer message at the end of the context instead of changing the first one. For reasoning effort or response format, append a configuration_update item and keep the original request-level setting the same.
Does this cost me more tokens?
It can. OpenAI says that when reasoning items are dropped the model may have to redo some reasoning, which can increase token usage, cost and latency. A changed prefix also cuts prompt cache reuse from that point on.
Why is OpenAI doing this?
OpenAI's docs describe reasoning item removal as one of its safeguards against distillation, alongside removing reasoning when you switch model families, downgrade models or switch organizations or users.
Sources
- OpenAI Devs on X: reasoning items tied to conversation history
- OpenAI docs: Keep the prefix unchanged
- OpenAI docs: Reasoning models (reasoning item removal)
- OpenAI docs: Using GPT-6.2 (migration)
- OpenAI API changelog (Nov 17, 2026)
2026-11-21 00:30 PT against OpenAI's Keep the prefix unchanged guide, the Reasoning models guide, the Using GPT-6.2 migration guide, the API changelog (Nov 17) and @OpenAIDevs' November 19 post.
Want help building with tools like this?
Join the Shipping Skool community free. Paid members get live bootcamp calls every week and weekly-updated courses.
Join Shipping SkoolMore free guides
Chrome DevTools MCP: Let Your Coding Agent See the Page It Builds
Google's free, open-source way to give your coding agent a real Chrome window and the DevTools you already use. What it does, how it works, how to set it up, and the fine print.
Inkling 2 Mini: Run Thinking Machines' Looped AI Model on Your Mac
Thinking Machines' new open-weights model runs on a 32GB Mac with the wifi off. What it is, how the loop trick works, how to set it up, and the fine print.
fast-check: Property-Based Testing for JavaScript and TypeScript, Explained
A free, MIT-licensed testing library that tests a rule instead of a few examples. What it does, how it works, how we caught a one-cent bug we planted in a test app, and how to set it up on your own code.