OpenAI Forces GPT-6.2 Agents to Keep Conversation History Immutable
OpenAI's Responses API now preserves reasoning across turns when the conversation prefix stays intact, but edits silently drop prior thinking.
Takeaways
- GPT-6.2, Astra, and Sol now tie each reasoning item to its exact prior conversation history in the Responses API.
- Editing earlier messages, tools, or formats causes the API to drop reasoning that followed the change.
- OpenAI recommends an append-only pattern: add new
configuration_updateoradditional_toolsitems instead of mutating parameters. - New
input_transformationsobject exposes which reasoning items were removed and why. - A Reasoning removals section in the Usage dashboard surfaces the problem at account level.
- OpenAI's own compaction via
/responses/compactis exempt and preserves subsequent reasoning items.
OpenAI has changed how the Responses API preserves reasoning for GPT-6.2, Astra, and Sol. Each reasoning item is now bound to the exact conversation history that preceded it. When a later request modifies any earlier part of that history, the API removes reasoning items that follow the mismatch.
Agent developers who rewrite prompts, replace tool definitions, or summarize earlier turns may see higher token use and latency after adopting these models. The model may need to reconstruct discarded work, while the changed prefix also reduces prompt-cache reuse. OpenAI’s prefix guidance recommends preserving prior input and appending each update as a new item.
Stable history preserves prior reasoning
Prompt caching already depends on stable prefixes because cache matching starts at the beginning of a request. A change partway through the input limits cache reuse from that point forward. The newer models apply a related rule to reasoning preservation: OpenAI’s safeguards remove reasoning items whose original context no longer matches the submitted history.
Discarded reasoning can increase output latency, reasoning-token consumption, and cost. Quality may also decline when the model must reconstruct intermediate work from an altered or compressed history.
Edits that trigger a mismatch
Any modification before a reasoning item can invalidate that item and later reasoning that depends on it. Common triggers include:
- Shortening or truncating an earlier tool result
- Editing a developer message during a conversation
- Replacing earlier turns with a custom summary
- Changing the
toolsarray ortext.formatin a later request - Changing
reasoning.effortbetween turns - Editing top-level
instructionswhen using models older than GPT-6.2
These changes affect more than the edited item because later reasoning was generated from the original sequence. The server removes the affected state when the sequence no longer matches.
Build the context as an append-only log
An append-only input list preserves the history associated with existing reasoning items. Session-level changes should arrive as new input items while the original request configuration remains stable.
| Session change | Append-only implementation |
|---|---|
| Reasoning effort | Append a configuration_update item containing the new effort level. |
| Structured-output schema | Append a configuration_update item containing the new schema. |
| Available tools | Append an additional_tools item and preserve the original tools array. |
| Tools allowed for one turn | Use tool_choice with allowed_tools. |
| Developer instructions | Append a new developer message after the existing history. |
On GPT-6.2 and later, the API automatically appends top-level instructions after input. Those instructions are billed at the uncached input rate. Earlier models require extra care because changing top-level instructions can alter the effective prefix.
Managed compaction keeps reasoning intact
OpenAI-managed compaction provides an exception for long-running sessions. When an application uses /responses/compact or context_management, OpenAI can replace earlier context while retaining subsequent reasoning items.
Custom compaction should place the generated summary at the end of the current context. Inserting a summary before recent turns changes the prefix and causes reasoning from the original history to be removed. Applications that accept those removals can still replace the earlier history, with the associated cost and latency trade-offs.
Tool outputs and images should be reduced before their first submission. Truncating old tool results or shrinking previously submitted images changes the stored sequence and can invalidate later reasoning.
Trace removals in responses and usage data
The Responses API now returns an input_transformations object describing reasoning items removed by the server and the reason for each removal. For a prefix_mismatch, developers can match the reported reasoning id with the corresponding item in an earlier response’s output.
The Usage dashboard also includes a Reasoning removals section for account-level monitoring. OpenAI’s cache diagnostics can compare a request with an earlier response by setting prompt_cache_options.comparison_response_id. The diagnostic reports the first identified prefix difference on a best-effort basis.
Audit agents before changing models
Applications moving multi-turn workflows to these models should inspect every place that reconstructs or mutates input for the Responses API. Earlier implementations often changed tools, schemas, instructions, or old results between turns, with cache misses as the main visible consequence. GPT-6.2, Astra, and Sol can also discard persisted reasoning state after those changes.
- Preserve the original input sequence and request configuration.
- Append configuration updates, instructions, tool changes, and new turns.
- Use OpenAI-managed compaction when prior reasoning must survive compression.
- Preprocess large images and tool outputs before adding them to context.
- Log
input_transformationsand monitor Reasoning removals. - Compare affected requests with earlier responses through cache diagnostics.
Agents that preserve their history can reuse more cached input, retain eligible reasoning items, and avoid reconstructing work after each turn. For coding agents, research systems, and tool-heavy workflows, the conversation should function as a growing event log whose earlier entries remain unchanged.