On Friday, November 20, OpenAI published “Combatting adversarial distillation,” a detailed look at how it tries to stop rivals from copying its models by training on their outputs. The headline number is striking: in an internal red-team test, attacks that tried to recover a model’s protected reasoning from an earlier request succeeded 54.0% of the time against GPT-6 Astra with its original safeguards, and just 0.2% of the time against GPT-6.2 Astra with updated safeguards.
The part that matters for anyone shipping on the API is quieter: some of these defenses change how the Responses API treats reasoning items in your conversation history. If your app edits history, switches models mid-thread, or handles user IDs loosely, GPT-6.2 may silently throw away reasoning you assumed it kept.
What OpenAI announced
Distillation is a normal machine-learning technique: one model (the student) learns from data produced by another (the teacher). OpenAI’s worry is the unauthorized version, where someone harvests a frontier model’s outputs to train a copy that has similar capabilities but none of the safeguards. The company points to dual-use areas like cybersecurity and biology as the clearest risk.
OpenAI says its approach “combines adversarial testing, model training, classifiers, and API-level protections with investigations into coordinated attempts to extract model capabilities.” In practice that breaks down into two levels:
- Request level. Models are adversarially trained to refuse reasoning-extraction attempts while still explaining their answers to legitimate users. Input classifiers look for extraction attempts, and output classifiers check assistant messages and tool-call arguments for leaks, in both streaming and non-streaming responses.
- API level. With GPT-6.2 Astra and GPT-6.2 Sol, OpenAI says it now ties “a model’s protected reasoning to the conversation history that produced it.” If an earlier message is rewritten, the API drops the reasoning that followed it. Older model families with weaker safeguards also can’t read 6.2’s protected reasoning.
- Campaign level. OpenAI looks for coordinated patterns across requests and accounts. It says weekly enforcement actions have ranged “from thousands to tens of thousands of accounts,” with the rate rising sharply this past summer.
The full results table from the adaptive black-box test, averaged across six attacker models:
| Attack type | GPT-6 Astra (original safeguards) | GPT-6.2 Astra (updated safeguards) |
|---|---|---|
| Extract reasoning from an earlier request | 54.0% | 0.2% |
| Extract reasoning from the current request | 22.9% | 0.9% |
One caveat worth keeping in mind: as AI.info points out, the comparison spans both a different model and different safeguards, and these are OpenAI’s own internal numbers. OpenAI says it is now backporting selected improvements to GPT-6 Astra.
Why reasoning traces are the prize
OpenAI singles out protected reasoning, the model’s internal chain-of-thought, because it “can contain information the final answer leaves out.” In an internal study, a student model trained on exact reasoning traces from Astra-level teachers generally beat one trained on the visible summaries after fine-tuning. After a round of reinforcement learning, the exact-trace student still led at the largest inference budget, while the summary-trained student did better at lower budgets. A real edge, not a clean sweep.
The bigger fight behind this post
This isn’t abstract. On September 30, OpenAI said it disrupted a coordinated campaign that generated 16,000 extraction requests from more than 4,000 users on July 24 and 25. It attributed a core cluster to individuals associated with Moonshot AI, the maker of Kimi. In October, Reuters, citing The Information, reported that DeepSeek and Moonshot relied heavily on GPT-6 Astra outputs to train their latest models. None of the three companies immediately responded to Reuters. The same report notes Anthropic said its own anti-distillation measures cut harvested data by about 90% to 99%.
OpenAI’s new post frames this as a national security issue and says it supports the Chip Security Act, the AI OVERWATCH Act and the MATCH Act. Not everyone is buying the framing. Reaction on X includes critics calling it hypocritical, given that AI labs trained on public data in the first place. For developers, the practical changes are already live.
What changes for developers on GPT-6.2
OpenAI’s reasoning models guide spells it out. The API already removed reasoning items if you switched model families, downgraded to a less capable model, or switched organizations or users mid-conversation. “Starting with 6.2, reasoning items with a safety_identifier change or a modified conversation history (the prefix) will also be removed.”
The response tells you why through a field called input_transformations. The reasons that matter most:
prefix_mismatch: you inserted or edited content before a reasoning item. Rewriting an earlier tool result counts. Deleting whole items, or appending new items after the reasoning item, does not by itself trigger it.end_user_mismatch: thesafety_identifieron the request that created the item differs from the one reusing it. Sending it on only one of the two requests counts as a mismatch. Same value on both, or omitted from both, passes.model_mismatch: you switched families or moved to a less capable model in the same family. Moving up to a more capable model in the same family keeps compatible reasoning.organization_mismatch: the item came from another organization, or a different workspace under a different user.
The docs frame this as removal, not failure, so you won’t necessarily notice. The model simply loses reasoning it could have built on, which matters most in long agent runs.
Your GPT-6.2 checklist
- Keep history append-only. Don’t rewrite, redact or “clean up” earlier messages or tool results in place. If you need to fix something, add a new message after it. The docs confirm appending doesn’t trigger
prefix_mismatch. - Set a stable
safety_identifieron every request. Use one consistent value per end user, such as a hashed account ID, and send it on every call in the thread, or on none. Sending it on some calls but not others counts as a mismatch. - Log and alert on
input_transformations. Treat any unexpected removal as a bug signal. It’s the fastest way to catch middleware that’s mutating your history. - Review model routing. If your router drops a conversation down to a smaller model to save money, it loses reasoning. Our GPT-6.2 Astra and Sol breakdown and GPT-6.1 Terra guide cover the tiers.
- Stateless apps: replay everything. With
store: falseor Zero Data Retention, reasoning items come back withencrypted_contentby default. Preserve every output item and replay the full history unchanged. - Mind prompt caching, but don’t overclaim it. The guide separately notes that keeping the original prompt prefix intact preserves it for prompt caching. OpenAI doesn’t publish a specific cost impact for dropped reasoning, so measure your own token usage before and after.
If you’re building agents, these rules fit naturally with the logging and checkpoint habits in our guide to safe AI agent workflows.
Our take
A 54% to 0.2% drop is a big claim, and it comes from OpenAI’s own testing, so treat it as a strong signal rather than proof. The developer side is less glamorous but more certain. GPT-6.2 rewards clean, append-only conversation state and punishes sloppy history handling without telling you, unless you read input_transformations. Spend an hour this week auditing how your app builds its request history. That’s cheaper than chasing a mystery quality drop next month.


