OpenAI’s response to a newly disclosed API flaw shows how a narrow safeguard can fail when attackers combine features that work as designed. Security researchers at Xint found a way to extract raw reasoning traces from OpenAI models despite an earlier mitigation. OpenAI confirmed the flaw, addressed it and paid a bug bounty, but the episode raises a broader question for AI providers and enterprise security teams: did the fix close one exploit, or the weakness that made it possible?
The disclosure follows the “Stolen Thoughts” research report, which described a similar route to stealing model reasoning. That work raised concerns about large-scale data extraction, hidden prompt injections and malicious content entering public agentic rollouts. OpenAI had introduced mitigations after the earlier report, but Xint says its method got around them.
A workaround built from ordinary API features
Xint calls the technique “compaction smuggling.” In its technical account, the researchers explain how they moved one model’s reasoning into another model by putting it inside a compaction—a representation used to preserve conversation context.
The researchers first captured encrypted reasoning tied to a task, removed that task from the conversation history, and kept the reasoning intact. They then asked for it under a “solution” key in a JSON object, replacing spaces with tab characters. Xint said the formatting change was enough to pass OpenAI’s usage-policy classifiers.
Next, the researchers sent the encrypted compaction item to GPT-4.1 and GPT-4o and asked each model to reproduce its input. After decoding the JSON and changing the tabs back to spaces, they recovered the reasoning. Xint reported success at every reasoning effort level it tested.
The weakness, according to the researchers, lay in how the August safeguard was scoped. It blocked replaying reasoning into a different model, while compaction ran on the same model that had produced the reasoning. The workflow therefore crossed a boundary the mitigation did not cover.
OpenAI did not respond to a request for comment. The company has confirmed the issue to Xint, according to the report, and paid a bounty for its discovery. The source does not specify when OpenAI deployed its earlier or latest fixes.
Why a fix can miss the next path
Tim Becker, Xint’s lead researcher and author of its post, said some of the timeline remains unclear. The “Stolen Thoughts” report appeared on August 10, but Becker said he only knew OpenAI had addressed that earlier problem sometime before then. OpenAI also did not publish when it implemented a fix for Xint’s finding.
That silence reflects a challenge for security teams tracking AI services: providers can change model behavior without the familiar public record of a software patch. Becker described this as “security through obscurity,” and said protecting a model is “a very fundamentally hard problem to solve” because models change frequently. As he put it, they “are a moving target and that is part of the problem. Any mitigation is going to be somewhat brittle.”
Frank Dickson, principal analyst at Dickson Research, pointed to the interaction between features. “Compaction runs on the same model that produced the reasoning, so it sailed past the August mitigation, which only blocked replaying reasoning into a different model,” he said. “Swapping spaces for tabs was enough to slip past the usage-policy classifiers.”
Dickson summarized the gap with an analogy: “The vault was locked. The clerk holding the key would still read the letter aloud if you asked nicely. OpenAI did fix the bug it was shown. The trouble is that it was shown only one door.”
Repeated fixes for adjacent flaws are becoming a broader pattern among major AI providers. AWS earlier reported fixing a bug in April, then had to address it again in September. The parallel is a reminder that one tested attack path may not represent the full set of ways features can interact.
What enterprise security teams should ask
For organizations using AI APIs, the immediate concern is less about treating this particular disclosure as a crisis and more about how vendors test safeguards. Erik Avakian, technical counselor at Infotech, said Xint combined legitimate platform features to bypass protections. That makes the finding relevant to enterprise systems where separate components can create risks that are not apparent when each feature is examined alone.
Avakian advised CISOs to ask providers how they tested a fix across connected services and features. A patch for a reported exploit, he said, does not by itself establish that the underlying weakness has been addressed.
Brian Levine, a partner at Control Risks, made a similar point: “Vendors are fixing the specific attack path that was reported, not the underlying class of weakness, and researchers are walking right back in through a side door.” He urged security teams to ask what variant testing took place and to include regression notifications in contracts.
Other researchers emphasized independent verification. Pieter Arntz, a malware intelligence researcher at Malwarebytes, called the earlier mitigation incomplete and advised enterprises to retest after vendor fixes. Jeff Valdes, a director at Acceligence, warned that sensitive prompts and intermediate context could face similar exposure if safeguards focus on one route while other data paths remain open.
Aman Mahapatra, chief strategy officer at Tribeca Softech, argued that AI providers need to address security properties rather than individual exploit paths. He said platforms add features rapidly, and each new feature can create another route to the same protected data. His practical advice for CISOs: assume a reported fix may be partial until the provider explains what broader analysis supports it.
Agentic systems need a different security routine
Mahapatra also drew a comparison with a long-standing cryptography lesson: systems can become oracles when they process secrets and return information derived from them. In AI platforms, he argued, any model step that can access a secret and accept instructions can create a similar exposure. Natural language makes that interface unusually flexible.
Compaction illustrates the difficulty. Its portability across models supports workflows that let users switch models during a session, including agentic tools such as Codex. Yet that same capability can help transfer sensitive content between contexts. A useful product feature and a security weakness can share the same underlying mechanism.
Enterprise vulnerability programs often rely on CVE feeds and vendor advisories. Mahapatra said those processes can miss AI platform issues that arrive without a CVE, public advisory or patch notes. He recommended assigning someone to track researcher disclosures against the AI services in use and adding security notification requirements to provider contracts.
The key question after a vendor reports a fix is specific: did the change address the reported demonstration, or the broader class of behavior that enabled it—and what testing supports that claim? Xint’s disclosure suggests that the answer depends on how thoroughly providers examine interactions between features. For enterprise teams, that makes cross-feature testing and clear vendor explanations part of routine AI security work.