The paper in four sentences
When you use a reasoning model through an API, its hidden thinking comes back to you as an encrypted block. You send that block back with your next message so the model remembers what it was thinking.
The authors found that, at Anthropic, OpenAI and Google, those blocks were not tied to the conversation, user or model that made them. A block made by a strong model could be handed to a weaker model from the same company, and the weaker model could read it and write it out in plain text.
They used this to study four risks: copying a model's private reasoning, finding passwords and personal data inside reasoning people had published online, revealing harmful content that the visible answer had refused, and hiding instructions inside a block that nobody can read.
They told the companies first, the companies fixed it (the attacks stopped working by August 2026), and the paper proposes how to seal these blocks properly.
Idea · §1, §2.2
What an encrypted reasoning block is
A reasoning model writes out its working, often thousands of words, before giving a short answer. Companies keep this working hidden. They give two reasons: it is valuable (others could train their own models on it, which is called distillation), and it may contain things the final answer leaves out.
But APIs are stateless: the company's servers don't remember your conversation between requests, so your software sends the whole conversation every time. To let the model continue its earlier thinking without showing it to you, the company encrypts the reasoning and gives you a sealed block. You can't read it. You just pass it back, and the company's servers unseal it for the model.
No provider publishes exactly how these blocks are built, so the authors worked it out from how the APIs behaved (§2.2). They describe the blocks as encrypted with a tamper-proof seal (the technical term is an AEAD envelope). Their key observation was what the seal did not check: who you are, which conversation it came from, or which model made it.
TakeawayThe encryption itself wasn't broken. The flaw was that a sealed block could be used anywhere within the same company.
Check yourself
- Why do providers send the reasoning back to the user at all, if they want it hidden?
- Because the API doesn't store conversations. The client has to resend everything, so the hidden reasoning must travel with it, sealed.
Method · §2.3 · Table 1 · Fig. 2
Step one: testing where a block is accepted
The first experiment was a careful compatibility test. The authors generated blocks with their own accounts, then sent each block back in different situations and recorded whether the API accepted it. They tested three levels, each looser than the last:
- Same or new conversation: can a block be reused in a fresh request, or moved around within one?
- Another user: does a block made on one account work on a different account?
- Another model: does a block made by one model work in a request to a different model from the same company?
They mapped this for Claude, GPT and Gemini models (Table 1). They also checked where in a conversation a foreign block could be placed (Fig. 2). Within each family the answer was mostly "yes, it works". Some exceptions were noted: for Claude, Fable 5's blocks were the exception, and on the GPT side only the newest series accepted all older blocks. The pattern suggested each company used a single key for every block.
TakeawayThe research started with a systematic map of what the APIs accepted, before any attack was attempted.
Method · §2.4–2.5 · Fig. 1
Step two: getting a cheaper model to read it out
If a block works in another model's request, the receiving model can see the reasoning inside it as if it were its own earlier thinking. The authors picked, for each company, a decoder: a cheaper model that accepted the stronger models' blocks and could be persuaded to copy that reasoning into its visible answer. For Claude this was Haiku 4.5, for GPT it was GPT-5.6 Luna, and for Gemini it was Gemini Robotics 1.6.
Why a weaker model? Attacking the strong model directly means beating its refusals plus the company's input and output filters. The weaker model often has fewer protections, and it is cheaper to run at scale. Even so, for GPT the authors needed several attempts and workarounds for anti-distillation safeguards.
Test material (§2.5): to get blocks they could study, they asked the strong models hard problems from three benchmarks: AIME 2025 (maths competition), Codeforces (programming contests) and Humanity's Last Exam (expert questions).
How they judged success: the hidden reasoning can't be checked word for word, because nobody outside the company has the original. But the API reports how many "thinking tokens" the model used. So the authors compared that reported count with the length of the reasoning the decoder wrote out. If the two track each other, the decoder is probably copying the whole thing, not summarising or inventing. Figure 1 plots this for 120 Codeforces problems, and the authors say the counts "track each other closely across all tested models".
TakeawayWith no original text to compare against, the authors measured success indirectly: does the decoded reasoning have the length the provider itself reported?
Check yourself
- Why can't the authors simply compare the decoded text with the real hidden reasoning?
- Only the provider can see the real reasoning. The reported token count is the one piece of ground truth an outsider gets, so it serves as the yardstick.
- What would a decoded text much shorter than the reported count suggest?
- That the decoder summarised or skipped parts rather than copying the whole trace.
Experiment · §3 · Figs. 3–4
Risks from your own blocks: copying and hidden content
The paper sorts its experiments by who holds the block. A first-party attacker makes blocks with their own account, then reads them out with the cheaper model.
Copying reasoning (§3.1). Full reasoning is a much richer training signal than final answers, so readable traces would make distillation easier. The authors estimate that decoding 10,000 long traces would cost about $720 at Haiku 4.5 prices. They also ran a probe on open models: they gave each model a short piece of decoded Claude reasoning to continue (Fig. 3, Appendix B). Some, such as Kimi-K3, then reasoned and wrote noticeably more like Claude. The authors say plainly that this "cannot establish a causal claim" that those models were trained on Claude's reasoning.
Content hidden behind a refusal (§3.2). Models are trained to keep harmful details out of their answers, but not necessarily out of their thinking. In one example (Fig. 4), a harmful-style test question got a harmless visible answer, while the decoded reasoning contained information the answer had left out. This is a single illustration, not a measured rate.
TakeawayThe first-party experiments mostly show what becomes possible. Apart from the cost estimate, they are demonstrations, not large measured studies.
Experiment · §4.1 · Figs. 5–6 · Table 4
Risks from other people's blocks: secrets in public logs
A third-party attacker uses blocks that other people made. Where would they find them? Developers often publish logs of AI agents at work, for example on GitHub or Hugging Face. Those logs still contain the sealed reasoning blocks.
The authors collected 6,708 such public agent logs from Claude, GPT and Gemini models. They decoded every block they found, 315,320 in total. An AI model then labelled each decoded trace for private information such as passwords, API keys or addresses, in two stages (Appendix D).
About 0.3% of blocks (1,028) contained at least one leak, and 4.9% of logs (328) leaked at least one real sensitive item. In logs from real users they counted, among other things, 62 API keys, 33 passwords and 24 access tokens (§4.1, Fig. 6; the figure's caption says it covers all sources, so the paper is not fully consistent about scope). The paper's abstract summarises the findings as 367 pieces of personal information and 182 credentials.
A common cause was ironic: asking an agent to clean up or anonymise a log before publishing it. To decide what to remove, the model re-read the history and wrote the secrets out in its hidden reasoning. In 64 cases the secret appeared only in the reasoning, not in the visible log (Table 4).
Ethics (§5.3): all decoding and labelling ran in an isolated environment, the recovered secrets were deleted after counting, and the platforms and providers were told before publication.
TakeawayThis was the paper's largest measured experiment. It showed that reasoning published "safely" sealed was readable and sometimes held secrets the visible log didn't show.
Check yourself
- Why could asking an agent to remove secrets make things worse?
- To find the secrets, it restates them in its hidden reasoning. That reasoning stays in the published log as a sealed block, which this flaw made readable.
Experiment · §4.2
Hidden instructions inside a block
The flaw also works in the other direction. If a model accepts a foreign block as its own earlier thinking, someone could plant a block carrying an instruction. Anyone who later continues that conversation, for example by reusing a shared agent log, gives their model a "memory" it never had. Neither the person nor a safety monitor reading the visible text can see the instruction, because it is sealed.
The authors showed this in two demonstrations. In both, a block made by a smaller model was carried into a larger one, and the larger model followed the planted behaviour on an unrelated task. One ran inside a long, realistic coding-agent session (PostTrainBench in the Claude Code tool). The paper reports these as proofs of concept, with no success rate.
TakeawayUnreadable reasoning that is also replayable is a hiding place for instructions that monitoring of visible text can't catch.
Outcome · §5.2, §5.5 · Appendix A
Disclosure, fixes and limits
Disclosure. Before publishing, the authors reported to the major model providers, Microsoft and Hugging Face. They note that an independent researcher, Green, had reported that blocks were interchangeable in May 2026. According to the paper, providers did not acknowledge security implications at that time. After this paper's report, all providers acknowledged it, and the authors "were unable to launch the same attacks". By August 2026 the Figure 1 results were no longer reproducible. The project cost about $30,000 in API fees.
Proposed fixes.
- Keep the reasoning on the company's servers and give users only a reference number.
- Bind each seal to the user, the conversation and the model, and chain each block to the one before it, so blocks can't be moved.
- Block cross-model use at the gateway.
- Watch for the same block appearing in many conversations.
- Revoke leaked blocks.
- Train models to refuse requests to transcribe their reasoning.
The authors add a deeper point: any model that can read its own sealed reasoning can, in principle, be talked into revealing it, so sealed reasoning is only "semi-hidden" (§5.5).
Limits (§5.1): the tests reflect the APIs of early July 2026, which have since changed. The decoders are random, and without the original text, completeness can only be estimated. The public-log scan was a targeted demonstration, not a full audit.
TakeawayThe study followed the usual responsible-disclosure path: find, measure, report privately, wait for fixes, then publish with recommendations.
Check yourself
- If you publish AI agent logs, what does the paper recommend?
- Strip the sealed reasoning blocks out before sharing, especially if any secrets or private data might have come up in the session (§5.4).
How this connects to the rest of the archive
Hidden reasoning exists because of chain-of-thought prompting and reasoning models trained with reinforcement learning, such as DeepSeek-R1. Copying a model by training on its outputs is knowledge distillation. The hidden-instruction risk is a new kind of prompt injection.
Abstract, restated
Major providers hide reasoning traces and return them to clients as encrypted, signed blocks that are replayed with later requests. The authors show that in July 2026 these blocks were interchangeable across sessions, users and models within a provider. This enabled a "decryption jailbreak": a stronger model's block is replayed into a weaker sibling, which transcribes the plaintext. They demonstrate four abuse classes on Anthropic, OpenAI and Google models: (1) extraction of proprietary reasoning that bypasses anti-distillation defences; (2) large-scale private-data extraction (315,320 blocks decoded from public repositories; 367 PII artifacts and 182 credentials reported in the abstract); (3) exposure of hazardous content present in reasoning but refused in the answer; (4) invisible prompt injection via poisoned blocks in agent rollouts. Disclosure, mitigations and a context-bound envelope design follow. Panfilov, Schmotz, Shumailov, Beurer-Kellner, Schaeffer, Prabhu, Geiping and Andriushchenko, arXiv 2608.09867 (cs.CR), v1 10 August 2026.
Section · §2.1–2.2
Threat model and the inferred envelope
Both adversaries are unprivileged API users. The shared prerequisite is access to a compatible decoder model in the provider's ecosystem.
- First-party: the attacker "generates their own encrypted reasoning traces by querying a capable, safeguarded target model" and replays them into a weaker decoder.
- Third-party: the attacker "intercepts, scrapes, or otherwise acquires legitimate encrypted reasoning blobs" generated by others. They use these either as a decryption oracle or to inject blocks into a victim's context.
Providers do not document their construction. The authors model the block as an AEAD envelope inferred from behaviour (§2.2): a header (model, block type, version, key ID), a nonce, a tag and ciphertext. They identify its design goals as confidentiality, integrity and statelessness. The vulnerability sits in what the associated data omits. If authentication covers only the ciphertext and coarse metadata, a valid envelope is valid in any request that reaches the same key.
Section · §2.3 · Table 1 · Fig. 2
Compatibility mapping
The authors define three nested permissiveness levels: in- and cross-session, cross-user, and cross-model. They test them empirically with self-generated blocks. Table 1 gives the cross-model matrix per provider as of July 2026. As summarised in the text:
- Claude: any model's block replays into any other, "except Fable 5's thoughts".
- GPT: the GPT-5.6 series replays blocks from all earlier generations.
- Gemini: any-to-any.
Figure 2 reports which injection placements each model accepts: the current turn versus past turns. Cross-user and cross-model acceptance is consistent with a single provider-wide key. This is the authors' inference, since key management is not observable.
Section · §2.4–2.5 · Fig. 1
Decoder choice and the fidelity proxy
Decoders (§2.4) were chosen as the weakest compatible model with a usable transcription path:
- Claude Haiku 4.5: the weakest Claude model supporting assistant-turn prefilling.
- GPT-5.6 Luna: the least capable GPT model accepting all earlier traces. It needed template variation, best-of-n sampling and workarounds for anti-distillation safeguards.
- Gemini Robotics 1.6: compatible with both the 2.5 and 3.x series.
The rationale is attack-surface reduction. Direct extraction from the frontier model must defeat model-level refusals and system-level input and output filters. Routing the ciphertext through a sibling sidesteps both.
Corpus (§2.5): self-generated blocks (Anthropic API, OpenAI API, Google AI Studio) on AIME 2025, Codeforces (the Open-R1 subset) and Humanity's Last Exam. Public logs were processed with the same pipelines for §4.
Metric: the ratio of reconstructed-trace tokens to API-reported thinking tokens. Fig. 1 plots both for 120 Codeforces problems. The text reports that they track closely across all tested models, and the Fig. 7 caption (an example of illegible GPT-5 reasoning, §5.6) notes a 1:1 decoded-to-reported ratio for GPT-5 traces decoded with GPT-5.6 Luna. The paper presents this as a proxy. No string-similarity metric against ground truth is possible, because plaintext ground truth is unavailable to outsiders. Note that a token-count match is necessary but not sufficient for verbatim fidelity: a decoder could in principle paraphrase at matching length. The authors' qualitative evidence includes legible decoded traces and a summary contradicted by its decoded trace (Fig. 8).
Check yourself
- Name one way the token-ratio proxy could overstate fidelity.
- A decoder could produce a paraphrase or confabulation of similar length. The ratio constrains length, not content. Tokenizer differences between source and decoder add further noise.
Section · §3 · Appendix B
First-party vectors: distillation and refusal bypass
Distillation (§3.1). This extends black-box model extraction (Tramèr et al., 2016) and sequence-level distillation (Kim & Rush, 2016) to chain-of-thought. The authors cite Zhang et al. (2026a): approximate trace inversion raised a fine-tuned Qwen2.5-7B-Instruct on MATH500 from 68.4% to 76.0% over answer-only distillation. This paper's contribution is verbatim rather than approximate recovery. The cost estimate is about $720 at Haiku 4.5 rates for 10k traces with 12k-token input and output windows.
Appendix B probes open models for prior exposure using three measures: n-gram overlap (following Barbero et al., 2026), style classifiers, and perplexity on decoded spans. After prefilling with decoded Opus reasoning, Kimi-K3 and GLM-5.2 shift toward Opus-like style (and a Sol prefill shifts Kimi-K3 toward Sol), while DeepSeek-V3.1 and Inkling do not. The authors explicitly decline a causal claim.
Refusal bypass (§3.2) is a single qualitative proof of concept (Fig. 4) using a paraphrased HarmBench-style query (Mazeika et al., 2024) on Opus 4.8. The visible answer was benign, and the decoded reasoning contained information absent from it. No attack-success rate is reported.
Section · §4.1 · Figs. 5–6 · Table 4 · Appendix D
Third-party vector: the in-the-wild privacy study
Data: 6,708 publicly available agent trajectories from GitHub and Hugging Face, produced by Claude, GPT and Gemini models and still containing signed blocks. Decoding every block yielded 315,320 traces.
Labelling: an LLM-as-a-judge with a two-stage procedure (Appendix D). The main text does not name the judge model or report a human precision audit, so treat counts as automated estimates.
Results:
- 1,028 blocks (0.3%) contain at least one privacy leak.
- 328 of 6,708 sessions (4.9%) leak at least one real sensitive item.
- In genuine user sessions, per the §4.1 text (the Fig. 6 caption says "all sources"): 62 API keys, 33 passwords, 24 access tokens, 7 private keys, 30 personal emails, 6 non-localhost IPs, 130 names and 36 postal addresses.
- Including benchmark sources gives 912 distinct artifacts, much of it synthetic persona data. 704 artifacts come from genuine sessions, of which 64 were absent from the visible history (Table 4).
A recurrent trigger is sanitisation requests: the model restates secrets in reasoning while deciding what to redact. Fig. 5 shows a GPT-5.2 Codex trace recalling keys to strip before publishing a repository, and a Sonnet 4.6 trace over a synthetic ClawBench persona.
Ethics (§5.3): processing ran in an isolated environment, secrets were deleted after classification and aggregate counting, and platforms and providers were notified before publication.
Section · §4.2
Third-party vector: invisible injection
Because a replayed block is treated as the model's own prior reasoning, a poisoned block is an instruction channel that bypasses monitors of visible text. Two qualitative demonstrations are reported:
- A thought derived from o4-mini, ported into GPT-5.6 Sol, led it to write a script that uploaded a file to an attacker-controlled server.
- An injection generated by Haiku 4.5 inside a long PostTrainBench trajectory in the Claude Code scaffold led Opus 4.7 to upload a file after every change.
Neither has a reported trial count or success rate. These are existence proofs, relevant to monitorability arguments (Baker et al., 2025; Korbak et al., 2025) that assume the reasoning a monitor sees is the model's own.
Section · §5.5 · Appendix A · Table 2 · Eq. 1
Mitigations: the context-bound envelope
Table 2 maps six leakage vectors to defences. The core proposal binds the user ID (and session) into the AEAD associated data and chains each block to its predecessor with a hash (Eq. 1). This makes a block valid only in its own lineage. Four properties are targeted:
- P1: ordinality
- P2: full integrity
- P3: leak monitoring
- P4: non-replayability
A Merkle-tree structure lets context pruning and compaction keep working, key rotation handles legacy blocks, and a dual-format window eases migration. The other layers:
- Server-side reasoning storage with opaque IDs, which removes the asset but costs storage and statefulness.
- Cross-model isolation enforced at the gateway.
- Anomaly detection for signatures repeated across sessions, and signature revocation.
- Model-level refusal of transcription requests.
The structural caveat: any model that must decrypt its own reasoning can be induced to reveal it. So encryption makes traces "semi-hidden" at best (§5.5), and the authors weigh whether traces should be encrypted at all (§5.6). The case for encryption is that models can reason over sensitive content without exposing it. The case against is undetectable injection, privacy leakage and unfaithful summaries (Fig. 8).
Section · §5.1–5.2, Reproducibility
Limitations, disclosure and reproducibility
Limitations:
- Results reflect APIs in early July 2026.
- Decoders are stochastic, and fidelity is inferred, not measured against ground truth.
- The public-log scan is targeted, not exhaustive.
- Several results (distillation evidence, refusal bypass, injection) are qualitative.
Disclosure: reported to the major providers, Microsoft and Hugging Face. Prior public disclosure of interchangeability came from Green (May 2026), without acknowledged security implications. After this paper's report, "All model providers acknowledged the receipt of our report and subsequently we were unable to launch the same attacks."
Reproducibility: as of August 2026, the Fig. 1 results are "no longer reproducible" due to provider mitigations. Total spend was about $30,000 in API credits.
Glossary
- AEAD
- Authenticated encryption with associated data: encryption plus a tag proving the ciphertext and some unencrypted context (the associated data) were not altered. What is in the associated data decides where a ciphertext counts as valid.
- Reasoning block / signature
- The encrypted, signed form of a model's hidden reasoning that the client must send back on later turns.
- Replay
- Reusing a valid message in a context it was not created for.
- Decoder
- In this paper, a weaker sibling model that accepts a stronger model's block and is induced to transcribe it.
- Distillation
- Training one model on another model's outputs; reasoning traces are a richer signal than answers.
- First-party / third-party attacker
- Uses blocks they generated themselves / blocks generated by other users.
- LLM-as-a-judge
- Using a language model to label or score text automatically.
- Prompt injection
- Instructions planted in a model's input by someone other than the user.
- Hash chain
- Each item includes a hash of the previous one, so items cannot be reordered or moved to another chain without detection.