Key takeaways
- OpenAI’s November 20 report says GPT-6.2 Astra and Sol have strengthened protections for private reasoning, including checks on assistant messages and tool-call arguments.
- In OpenAI’s adaptive black-box evaluation, earlier-request extraction success was 0.2% for updated GPT-6.2 Astra versus 54.0% for GPT-6 Astra with original safeguards. These are vendor-reported results, not a general security guarantee.
- The API binds protected reasoning to the history that produced it. Rewriting earlier history can discard subsequent reasoning; the linked guide describes append-only alternatives and an exception for OpenAI compaction.
- Builders should inspect input_transformations for reasoning removals. Cache diagnostics alone cannot establish that reasoning was reused.
What OpenAI announced
OpenAI said on November 20, 2026 that it had strengthened protected-reasoning safeguards in GPT-6.2 Astra and GPT-6.2 Sol. Its report describes defensive model training, input and output classifiers, API restrictions on reusing reasoning, and investigations of coordinated unauthorized distillation. The API protections tie a model’s private reasoning to the conversation history that produced it and prevent older model families with weaker safeguards from reading GPT-6.2 reasoning.
This is a safeguard and API-behavior update to already announced models, not a new model launch. The report does not introduce a new callable model ID, price, context limit or access tier. It says selected safeguard improvements are also being applied to GPT-6 Astra; it does not establish that every older deployment has identical protection. We have not checked account-level rollout or called the API.
The extraction numbers are OpenAI’s measurements
OpenAI’s table compares GPT-6 Astra with original safeguards against GPT-6.2 Astra with updated safeguards. In adaptive black-box red-teaming, success at extracting reasoning from an earlier request was 54.0% versus 0.2%. For reasoning from the current request, it was 22.9% versus 0.9%. OpenAI says the results are aggregated across six attacker models and the setup closely mirrors production deployments.
These are vendor-reported benchmark results. The comparison changes both the model and its safeguard configuration, so it does not isolate the effect of one classifier, one API restriction or one training change. A low rate under this evaluation does not prove that extraction is impossible, establish the production incident rate or measure every form of distillation. The published table concerns Astra; it is not a separate quantitative result for Sol.
Distillation itself is a normal training technique. OpenAI’s concern here is unauthorized transfer of capabilities without comparable safeguards. Its enforcement and attribution statements remain company claims; this briefing does not independently validate campaigns or infer that ordinary model training is abusive.
A history edit can now have a reasoning cost
The practical integration consequence is in OpenAI’s linked Keep the prefix unchanged guide. A reasoning item’s prefix is the conversation history before it. Shortening an earlier tool result, rewriting an earlier developer message or replacing old turns with a summary changes that prefix. The guide says newer frontier models drop reasoning items that follow a prefix change as part of the safeguards.
OpenAI warns that the model may then redo reasoning, increasing token usage, cost and latency. Output quality may also fall if the lost reasoning cannot be recovered. This is separate from the familiar prompt-cache penalty: a changed prefix can reduce cache reuse, but a cache hit does not prove that private reasoning survived. The guide recommends an append-only pattern as far as possible.
For an agent builder, our analysis is straightforward: a middleware optimization that rewrites past tool output is no longer merely a storage or prompt-size decision. Preserve the exact items originally sent, or deliberately test the trade-off. Shorten long tool outputs and downsize files before their first submission rather than silently editing them in later turns.
The documented alternatives and exceptions
The guide recommends appending a configuration_update item when changing reasoning effort or structured output schemas while leaving the original request-level settings unchanged. For tool changes, it describes additional_tools for additions and tool_choice with allowed_tools for restrictions, preserving existing tool definitions in order. These are documented integration options, not API calls we executed.
Instruction handling has an important model distinction: reusable instructions belong in the first developer input message, with updates appended rather than rewritten. For models starting with GPT-6.2, the guide says top-level instructions become turn-scoped developer messages appended after input and are billed at the uncached input rate. Check the current API schema before changing an SDK integration.
Compaction is not a blanket prohibition. OpenAI says its own /responses/compact and context_management mechanisms retain subsequent reasoning despite the prefix change, although cache misses remain difficult to avoid. For explicit compaction, it says to omit instructions and pass the returned window onward in its original order. Custom compaction has different trade-offs: the guide recommends placing the compacted item at the end or accepting that reasoning following the changed original history will be dropped.
What builders should check next
Review any layer that truncates prior tool messages, rewrites instructions, reorders tools or summarizes history. On a synthetic multi-turn task, compare your existing behavior with an append-only version and record output correctness, token use and latency. This is a proposed regression check, not AccessAllGPT hands-on evidence.
OpenAI documents input_transformations in Responses API responses as the way to see which reasoning items were removed and why. For prefix_mismatch, match the removed item’s id with the earlier response output. Prompt Cache Diagnostics can help find a first prefix difference by comparing response IDs, but the guide explicitly says those diagnostics cannot verify reasoning reuse. Keep those two observations separate in your monitoring.
For buyers, ask the agent supplier whether its memory, compaction and tool-management layers preserve these semantics. The useful question is not whether a vendor promises uninterrupted thinking; it is whether the integration can show when history changed, what the API discarded and how the finished task was affected.
A small regression checklist for reasoning-state changes
Proposed checks using synthetic tasks and supported APIs; no attempt to reveal private reasoning is needed.
Entries stay in this browser tab and are not submitted to AccessAllGPT. Blank responses are copied as [Unresolved].
Identify code that edits earlier messages or tool results. Preserve original items in an append-only comparison run.
Record input_transformations and prefix_mismatch removals separately from cache diagnostics, latency, token use and final-task correctness.
Distinguish OpenAI compaction from custom summarization. Follow the guide’s ordering and instruction rules, then test the actual client behavior.
Primary sources
Browse the publication-wide evidence index →
- Combatting adversarial distillationOpenAI · Reviewed: November 20 date; request-level safeguards; API-level protections; resistance to reasoning extraction; adaptive black-box table and six-attacker aggregation; enforcement statements · Retrieved · Supports: First-party evidence for announced GPT-6.2 safeguard behavior and OpenAI-reported extraction results. Does not independently establish effectiveness, production attack rates, campaign attribution or Sol-specific numerical performance.
- Keep the prefix unchangedOpenAI API documentation · Reviewed: Prefix definition; integration changes; configuration_update and additional_tools; GPT-6.2 instructions; OpenAI versus custom compaction; input_transformations and Prompt Cache Diagnostics · Retrieved · Supports: Current documented API integration behavior and troubleshooting recommendations. Retrieval does not establish when every documented option launched or prove account-level support and SDK compatibility.
Limitations
Public-source briefing, not an independent safeguard evaluation. No authenticated API calls, extraction attempts, SDK compatibility tests or latency and cost measurements. OpenAI’s figures compare different models and safeguard stacks; the table does not report a separate Sol result. The documentation is mutable and its retrieval date is not a release date for every option.
Disclosures
OpenAI did not review or endorse this article. AccessAllGPT Research is operated by NeuralArc. This is public-source reporting, not a sponsored test or claim of private model access; publication-wide relationships appear on the disclosures page.



