Explainer / Published 2026-10-31

A compaction bug let researchers copy GPT-5.6's hidden reasoning as plain text

Security firm Xint used OpenAI's compaction step to pull encrypted reasoning out of gpt-5.6-sol and have cheaper models repeat it. OpenAI confirmed the flaw and fixed it on October 23.

Two clear glass jars on a bright ledge; the larger one holds folded teal paper, and the smaller one beside it is empty, with thin light reflections along their rims.
Conceptual illustration of compressed material held in a container; it does not depict OpenAI systems or a real interface.

THE SHORT VERSION

  • Security firm Xint showed that OpenAI's compaction feature, which shrinks a long conversation into an encrypted item, could be instructed to copy a model's hidden reasoning out in plain text.
  • The technique targeted gpt-5.6-sol and worked around a fix OpenAI shipped in August against replaying encrypted reasoning into weaker models, because compaction runs on the same model that produced the reasoning.
  • OpenAI confirmed the problem and fixed it on October 23, according to Xint, which says it cannot prove the extracted text is word-for-word the model's reasoning.

The feature and the flaw

OpenAI's reasoning models work through a problem before answering, and the service normally returns that reasoning as an encrypted item the user cannot read. Xint, a security firm, found that the compaction feature — which shrinks a long conversation into a smaller encrypted item so the context can carry forward — could be turned into a way to copy the hidden reasoning out as plain text.

The method got past protections OpenAI added in August against this kind of reasoning theft, and OpenAI confirmed the problem and fixed it on October 23, according to Xint. The disclosure matters less for what it reveals about one model than for what it says about features that move encrypted state between models.

Asking the model to copy itself

Xint ran the technique against gpt-5.6-sol using math and algorithm puzzles its researchers wrote themselves. It sent a task, kept the encrypted reasoning the model returned, then called the compaction step on the same model and told it to copy that reasoning into the compacted item word-for-word, changing every space to a tab to get past OpenAI's usage-policy filters.

Because compaction items can move between models, Xint then passed the item to the cheaper gpt-4.1 and gpt-4o models and asked each to repeat its input exactly. Both did. The reasoning that came out came from Xint's own requests, and the firm did not claim the method could reach another user's reasoning.

Why the earlier defence did not cover it

In August, researchers behind a paper called Stolen Thoughts showed that encrypted reasoning from a strong model could be replayed into a weaker model from the same company, which would then repeat it as plain text. OpenAI and others blocked that cross-model replay soon after.

Compaction got past the block because the compaction step runs on the same model that produced the reasoning, so the operation never looks like the cross-model replay the fix was written for. The lesson is structural: a defence keyed to model boundaries can be bypassed by a feature that legitimately crosses those boundaries itself.

What Xint says it cannot show

Xint says it cannot prove the copied text is word-for-word the model's real reasoning, because it never had the original to compare against. Two cheaper models each repeated the item and produced the same text, which rules out errors in the copying step but leaves open the possibility that compaction reworded the text.

That gap matters for how the finding should be read. If the output is a paraphrase of reasoning rather than the reasoning itself, the exposure is a leak of reasoning content through a different route, not necessarily a bit-exact extraction. Either way, the encrypted item was not as opaque as the design assumed.

The part that is a policy question

The technique deliberately changed spaces to tabs to get past usage-policy filters, which puts part of the story outside the technical layer. Filters that scan for requests to reproduce hidden text are guarding against a behaviour, and a user who rephrases the instruction can test whether the guard is robust.

That is the harder problem for any provider. Adding filters raises the cost of abuse, and it does not close a path that a model is capable of following when asked in the right way. The fix OpenAI shipped on October 23 is the one that matters here; the underlying tension between usability and opacity remains.

Why reasoning extraction matters beyond one model

A model's reasoning trace can expose more than an answer: it can reveal the shape of the checks a model applies, the pathways it prefers and, in an agentic setting, the steps it takes before acting. For competitors, that is data about training; for attackers, it is a map of where a system can be steered.

It also complicates the promise made to users. If reasoning is encrypted because it may contain sensitive prompt content, then a feature that exports it is not a cosmetic bug. The finding joins a series of incidents this year in which the boundary between what a model shows and what it keeps internal turned out to be enforced by convention rather than by architecture.

What to check next

Three things would clarify the risk: whether OpenAI's October 23 fix covers compaction on other models, whether other providers with cross-model context features are affected, and whether vendors publish tests that attempt this class of extraction. None of those is settled in the disclosure reviewed here.

Related coverage on this site includes the Claude Code extension compromise, tampered AI hardware changing chatbot answers and Proton's account of its AI reckoning. All three describe the same pattern: the trust boundary moves, and the controls lag behind it.

What a fix on one feature covers

A patch shipped on October 23 closes the path Xint demonstrated, and it says less about other features that move compressed state between models. Context summarisation, memory hand-off and cross-model routing all sit in the same design space, and none of them is addressed in the disclosure reviewed here.

That is the practical question for anyone running these systems: whether the fix is a rule about compaction or a rule about exporting encrypted items at all. Only the second would generalise, and the reporting does not say which was implemented.

Sources & reporting limits

  1. OpenAI compaction flaw let researchers extract hidden reasoning
  2. Compaction smuggling: extracting reasoning traces
Keep the thread.

Follow Products to find related stories on your next visit.

THE WEEKLY EDIT

The week, made clear.

Stories worth understanding, brought together in one weekly edition.

Share this page

Instagram, TikTok & other apps

Copy the page link, then paste it where your chosen app supports links. You choose whether to send or publish.