Hidden reasoning from major AI APIs can be decoded and leak secrets
Encrypted "thinking" blocks from OpenAI, Anthropic and Google can be decoded — and they leak real secrets
A reconstruction pipeline turned 6,708 public agent trajectories into 315,320 recovered reasoning blocks, exposing 704 privacy artifacts users never knew were exposed
Providers encrypt chain-of-thought to hide it from users and competitors, but the encryption is reversible enough that hidden reasoning can be decoded at scale from data already public on GitHub and Hugging Face — turning a safety/IP feature into a new leak surface for credentials and PII.
Why the decoding is credible
The strongest evidence isn't the leak count itself, it's the calibration check: across 120 Codeforces problems, the token count of the decoded reasoning tracks the hidden thinking-token count the API itself reports. That correlation is the thing that separates "we found some text" from "we recovered the actual hidden reasoning" — it's an independent signal (the provider's own token accounting) confirming the decode is faithful, not fabricated or hallucinated filler.
Scale of the pipeline
from GitHub and Hugging Face, containing encrypted reasoning blocks
from genuine, non-benchmark user sessions
What kind of secrets came out
555 is the remainder of 704 total artifacts not itemized by the source beyond the four named categories.
64 of the 704 artifacts existed only inside the hidden reasoning blocks — invisible in the session a user or reviewer would normally see. This means redacting or auditing visible chat logs is not sufficient; the hidden trace is a separate, unmonitored channel where secrets can leak even when the visible output looks clean.
Why this matters beyond the leak count
Encrypted reasoning was sold as a boundary: users can't see it, and therefore can't be exposed by it. This work shows that boundary is porous when the same encrypted blocks are captured and stored in agent trajectories that then get published publicly — a workflow that is already common practice for sharing agent demos and benchmarks. The API's own thinking-token accounting effectively becomes the key that makes the decode verifiable, which is an uncomfortable irony: the transparency feature meant to build trust in reasoning models is what confirms the leak is real.
What's still unclear
The source does not specify whether this is a systematic vulnerability in the encryption scheme itself or a side-channel exploiting how reasoning tokens are packaged for return to the model.
No confirmation from OpenAI, Anthropic, or Google is cited — this is presented from the researchers' side only.
The 704 artifacts come from a subset described as 'genuine, non-benchmark user sessions' within the larger 315,320 reconstructed blocks; the source does not state what fraction of the full corpus this subset represents.
What would confirm or defuse this
- 01
Any statement or patch from OpenAI, Anthropic, or Google acknowledging or closing the decoding method
- 02
Independent replication of the Codeforces token-count correlation on a fresh problem set
- 03
Whether vendors change how reasoning blocks are signed/encrypted in response
- 04
Whether platforms hosting agent trajectories (GitHub, Hugging Face) begin stripping or flagging encrypted reasoning blocks before public upload