Back to Blog

GPT-6.2 CoT Security: Prior-Turn Leaks Fall to 0.2%

Daily News7878
GPT-6.2 CoT Security: Prior-Turn Leaks Fall to 0.2%

OpenAI reports that extraction of protected chain-of-thought from GPT-6.2 Astra dropped from 54.0% to 0.2%. The headline number is the least interesting part. The design underneath it — conversation-bound reasoning, classifier gating, and weekly account enforcement — is what changes how teams should build on reasoning models.


1. What OpenAI actually disclosed

On November 20 (local time), OpenAI published an update on its defenses against adversarial distillation. The subject was narrow and technical: the protection of internal chain-of-thought (CoT) reasoning in two frontier models, GPT-6.2 Astra and GPT-6.2 Sol.

The framing matters. Adversarial distillation is not ordinary model stealing. It is the deliberate use of a frontier model's outputs to train a second model until that second model approximates the first. The student inherits capability. It does not inherit the safety stack that was trained alongside that capability.

That asymmetry is the whole risk model. A model that can reason through protein design or exploit development, minus the refusal behavior and the red-team hardening, is a materially different artifact from the teacher. OpenAI states the concern directly: high-risk capability in domains such as cybersecurity and biology can migrate out of a model that was constrained, into one that was not.

Under that threat model, the reasoning trace is the highest-value output a model produces. It contains the search: the backtracking, the abandoned branches, the self-corrections, the intermediate hypotheses. For a student model, that is a compressed curriculum. It shortens the distance between "can answer" and "can reason."

OpenAI's update quantifies how much of that trace could be pulled out before and after the new defenses.

Attack classPrior safety stackGPT-6.2 safety stackRelative reduction
Extraction of reasoning from previously submitted requests54.0%0.2%≈99.6%
Extraction of reasoning from the current request22.9%0.9%≈96.1%

Both figures were measured in OpenAI's internal adaptive black-box red-team tests, aggregated across six distinct attack models. "Adaptive" is the operative word: the attackers were allowed to see the defense and adjust. A static attack suite would have produced a flattering and useless number.

Two structural observations before the charts.

First, the pre-defense baseline for *previous* requests (54.0%) was far worse than the baseline for *current* requests (22.9%). That gap tells you where the leak lived. It was not in a single prompt. It was in accumulation — reasoning from earlier turns remaining retrievable later, through prompt steering, session reuse, or transcript manipulation.

Second, both post-defense numbers are non-zero. 0.2% and 0.9% are not zero. Any operator reading these figures as a guarantee is reading them wrong.


2. Two benchmarks, four curves, one shape

OpenAI published two evaluation plots. They measure different things, and they should be read together, not separately.

ExploitBench measures *capability coverage*: how much of the teacher's functional capability the student recovers. It is plotted against inference budget, measured in weighted output tokens, from the lowest to the highest setting.

SEC-bench Pro measures *score* on a security-relevant task suite. Same x-axis, same four conditions.

The four conditions are the important part of the design. Each benchmark is run under two attack pipelines — fine-tuning and reinforcement learning — and each pipeline is run on two data types: reasoning summaries versus exact reasoning traces.

Reading the published curves at the low and high ends of the budget axis gives the following approximate picture.

ConditionExploitBench, low → high budgetSEC-bench Pro, low → high budget
Reasoning summaries · after fine-tuning≈5% → ≈14%≈0.5% → ≈1%
Exact reasoning traces · after fine-tuning≈7% → ≈20%≈0.5% → ≈12%
Reasoning summaries · after RL≈14% → ≈27%≈1% → ≈30%
Exact reasoning traces · after RL≈12% → ≈36%≈0% → ≈39%

Four readings follow from that table.

Exact traces beat summaries where it counts. At the top of the budget range, the solid-orange line finishes above its dashed counterpart on both benchmarks. On ExploitBench the two start close together at low budget and separate as tokens accumulate; on SEC-bench Pro the separation is visible almost immediately. That is the expected result, and it explains why summaries exist as a commercial product in the first place. A summary is a lossy compression of the search. It transfers conclusions. A trace transfers method.

RL-trained students scale with budget; fine-tuned students do not. On SEC-bench Pro, the two fine-tuning curves flatten near the floor — the exact-trace condition reaches roughly 12% and then stops climbing, while the summary condition never leaves single digits. The RL curves, by contrast, keep rising across the entire budget range and end near 30% and 39%. The interpretation is not that RL is a worse attack. It is that RL *uses* the budget. Given more tokens, an RL pipeline can convert trace signal into behavior; a fine-tuning pipeline saturates.

The residual risk is concentrated in the tail. The gap between the solid-orange line and everything else is widest at the high-budget end. That is where the defense has the least margin, and it is precisely the regime a determined distillation campaign would operate in. The defense's job is not to flatten the whole plot. It is to keep the top-right corner expensive and noisy.

Summaries are not safe, they are merely cheaper. A reader could conclude from SEC-bench Pro that summaries are harmless. ExploitBench contradicts that: summaries after RL reach roughly 27% capability coverage. Summaries reduce the rate of transfer. They do not stop it.

One caution on these plots: they are internal evaluations with six attack models, plotted on a shared budget axis, and the fidelity of any value read off a chart is approximate. The shapes are the finding. The decimal places are not.


3. Three controls at the boundary, one at the architecture

OpenAI describes a two-layer protection design. The layers differ in scope, and conflating them is a common mistake.

Layer 1 — protect each model interaction. Three controls operate inside a single request-response cycle:

Layer 2 — detect and disrupt campaigns across the system. Individual interactions are the wrong unit for a distillation operation. A campaign is distributed by design: many accounts, many sessions, low volume each, aggregated offline. So Layer 2 works at account and network level: activity correlation within and across accounts, investigation and enforcement, and an automated red-teaming loop feeding findings back into Layer 1.

The diagram's arrows are the point. Signals from Layer 1 inform investigations. Findings from investigations improve protections. Automated red teaming closes the loop. This is a detection-and-response architecture, not a filter.

Then there is the change that is not a control at all but an architectural property, and it deserves separate treatment.


4. Reasoning is now bound to the conversation that produced it

This is the most consequential engineering detail in the disclosure, and it is easy to skim past.

OpenAI states that GPT-6.2 Astra and GPT-6.2 Sol bind protected reasoning content to the conversation history in which it was generated. If an earlier message in that history is modified, the API discards the downstream reasoning derived from it. Separately, older models that do not carry the patch cannot read the protected reasoning of these two models at all.

Three consequences for anyone building on these APIs.

Reasoning becomes stateful, not stateless. A trace is no longer a free-floating artifact you can store by response ID and re-inject. It carries a provenance constraint. Editing turn 3 invalidates the reasoning attached to turns 4 through n. Pipelines built on the assumption that completions are immutable records will break silently — the call succeeds, the reasoning is simply gone.

Replay and branching need rework. Techniques that fan out from a checkpoint — best-of-n sampling, branch-and-merge prompt experiments, conversation forking for A/B comparison — all depend on being able to reuse a prefix and its derived state. If the prefix is edited, the derived reasoning is void. The correct response is to treat a modified turn as a new conversation root for reasoning purposes, and to budget for recomputation rather than assume cache hits.

Caching layers become a correctness risk. Any intermediary that stores and reassembles model output — a proxy, a response cache, a gateway — must understand this binding, or it will hand back reasoning that the upstream considers invalid. Verification is not optional here: an intermediary that serves stale reasoning after a turn edit is producing output the vendor's own API would have refused.

That is also the honest limit of what an intermediary can do. Edge controls — key management, per-tenant quotas, request logging, policy enforcement — are real, and they belong at the boundary. A routing layer such as the 4sapi API gateway can pass the invalidation signal through cleanly and refuse to serve reasoning that no longer matches its prefix. What it cannot do is substitute for the binding itself, which is enforced inside the vendor's API.


5. Enforcement at a scale that implies an industry

OpenAI's enforcement disclosure is short and unusually concrete.

The company says it takes action every week against accounts associated with unauthorized distillation. The volume ranges from thousands to tens of thousands of accounts. Enforcement activity increased noticeably during the summer. Beyond individual accounts, OpenAI says it investigates coordinated networks running large-scale account operations, and that it shares attack indicators with other model providers to help them identify related abuse.

Two implications.

First, distillation at scale is an industrial activity, not a hobbyist one. Weekly actions against five-figure account counts describe a supply chain: account farming, proxy rotation, budget distribution across tenants, output aggregation. The detection problem is therefore graph-shaped, which is exactly why Layer 2 exists separately from Layer 1.

Second, cross-provider indicator sharing is a notable precedent. Model abuse indicators — request fingerprints, extraction prompt families, account-network topologies — are being treated as shareable threat intelligence. Providers compete on capability and cooperate on abuse. That arrangement has no formal governance yet, and it will need some.


6. The counterintuitive safety result

Buried in the disclosure is a research finding that inverts the usual intuition about what to hide.

OpenAI compared two student models trained on the same teacher. One was trained on the teacher's final answers plus reasoning summaries plus tool-call logs. The other was supervised on the teacher's full reasoning trajectories, with process-level supervision. On OpenAI's internal network-security safety evaluations, the second model — the one trained on complete traces — transferred safety behavior *better*.

The mechanism is plausible. Outcome-only training rewards the destination and leaves the route unconstrained. The model learns shortcuts that produce correct answers, and shortcuts are exactly what safety training has to suppress under adversarial pressure. Process supervision exposes the deliberation, including where the teacher paused, reconsidered, and declined. A student that has seen refusal happen mid-trace has a template for refusing.

Which produces the dilemma this whole program sits inside. The same traces that make a student *safer* are the traces that make distillation *effective*. You cannot publish full traces to improve safety transfer and simultaneously expect them to be hard to extract. Protection has to be selective: useful for legitimate supervised training, resistant to adaptive black-box extraction, and auditable enough that safety researchers can still study the mechanism.

The 54% → 0.2% figure is the current answer to that trade-off, not a resolution of it.


7. What this changes for teams shipping on model APIs

Six practical consequences, ordered by how soon they bite.

Treat reasoning traces as governed data with a lifecycle. They are no longer append-only logs. Each trace has a validity condition tied to the prompt prefix that produced it. Retention policies, audit exports, and incident replays all need a provenance field. Teams that store traces purely for debugging will discover this the first time an edited prompt returns a response with no reasoning attached.

Verify your intermediaries against the binding. Proxies, caches, and routing layers sit between your application and the vendor API. Each one is a potential place where reasoning gets reassembled from a stale prefix, or where a turn edit is passed through without invalidating derived state. This is now a correctness question, not a performance question.

Budget caps are a defense, not just a cost control. The plotted curves are functions of inference budget. The high-budget end is where extraction succeeds. If your workload does not need long reasoning traces, capping output tokens reduces exposure surface as well as spend. Two goals, one control.

Ask vendors for domain-specific extraction numbers. A benchmark score on a generic suite tells you about the generic case. If you operate in security, biology, or finance, ask what the extraction success rate is on *your* task distribution, under an adaptive attacker, at your budget. The answer will differ from the headline.

Read distillation clauses as technically enforced terms. Contract language prohibiting model extraction now has detection and enforcement behind it: weekly account actions, cross-account correlation, indicator sharing. The operational risk of quietly distilling a frontier model has moved from "contractual" to "detectable." Compliance programs should reflect that.

Separate the two layers in your own architecture. Interaction-level controls (refusals, classifiers, per-request policy) and campaign-level detection (account correlation, aggregate anomaly review) are different systems with different data. Most internal deployments have the first and lack the second, because the second requires joining logs across tenants and time windows. A centralized API gateway such as 4sapi sits at exactly that boundary, which makes it the practical place to enforce per-tenant quotas, keep request logs coherent across sessions, and apply policy before traffic reaches the vendor. That is an operational argument, not a security guarantee: the model-side defense is still the vendor's.


8. What the disclosure does not settle

Four open questions worth stating plainly.

Generality of the number. 0.2% is measured against six internal attack models under adaptive conditions. It is a strong result. It is not a proof. Attack diversity is the binding constraint on any claim like this, and OpenAI does not publish the composition of its attacker set.

Debuggability cost. Binding reasoning to conversation history makes incident replay harder for defenders too. Enterprises that need trace-level evidence for audits, safety review, or regulated-model documentation now operate under the same invalidation rules as attackers.

Legitimate distillation. Not all distillation is adversarial. Vendors license model outputs for sanctioned student training. A protection stack tuned for adversarial extraction risks taxing the licensed path. Selective release — summaries for the many, traces for the few under agreement — is the obvious answer and the hardest one to enforce.

The ceiling of enforcement. Weekly actions against tens of thousands of accounts describe a defensive posture that scales with attack volume. It does not describe a posture that closes the channel. Account-level enforcement raises the cost of a campaign. It does not eliminate the economic incentive, which is that a well-built student model is cheaper than the RL run that produced the teacher.


9. Bottom line

The interesting claim in this disclosure is not that extraction fell to 0.2%. It is that reasoning traces have been reclassified — from an output you own, to a scoped, revocable, monitored resource that a vendor lends you under conditions.

Tags:GPT-6.2 AstraGPT-6.2 SolOpenAIChain of ThoughtCoT SecurityAdversarial DistillationLLM Security

Recommended reading

Explore more frontier insights and industry know-how.