OpenCode described the incident as a large-scale distillation attack. The phrase sounds academic. In practice it means someone ran a machine in a loop, spending other people's API credits to harvest model output at volume.
What OpenCode confirmed about the Console breach
The open-source coding agent disclosed the incident on October 17 and 18 and started emailing users the same weekend. Its Console product, the hosted side of the project, had been compromised.
The company put the exposure at 1.4% of Console users. It also narrowed the group further: only accounts that had connected a third-party AI provider to Console were affected. Everyone else got nothing, and OpenCode says anyone who didn't receive an email wasn't in the affected set.
No email, no exposed key.
That's a useful detail for the worried. It's also the kind of statement that only covers what the company knows so far.
Why the blast radius stopped at 1.4% of OpenCode users
The stolen material was API keys, not passwords and not chat history. Those keys lived in a legacy system that OpenCode was in the middle of retiring, and the company says an attacker got unauthorized access to it.
Third-party keys for OpenAI, Anthropic, and Google sat in that system because Console needed them to route requests on a user's behalf. Anyone who never linked a provider account had no key stored there.
That explains the narrow percentage without making it reassuring. A key is a bearer credential. Whoever holds it can spend the account's money until someone rotates it.
OpenCode says it has found no signs that user data was exposed. Treat that as the company's current assessment, not a verified finding. No outside firm has published an audit.
The distillation attack behind the stolen keys
Distillation is how smaller models learn from bigger ones: feed the big model's answers into training for a cheaper system, then repeat until the student stops needing the teacher. Do it through an API and you're paying per token, which is why labs watch for it.
An attacker with a pile of stolen keys doesn't pay. They run high-volume automated queries, collect outputs, and walk away with a training set billed to someone else. OpenCode used the term "distillation attack" for exactly this pattern.
The victims got two problems at once. Their provider bills spiked, and their keys stopped working when the providers cut them off.
Rescana's write-up on the incident cites user reports of losses ranging from hundreds to thousands of dollars. That's a third-party roundup of self-reported figures, not an OpenCode count, and it shouldn't be read as a total. Rescana also maps the activity to known credential-theft techniques, which is analysis rather than attribution.
OpenCode's timeline starts at 00:30 UTC on October 17
BleepingComputer, citing OpenCode, puts the earliest possible key exposure at 00:30 UTC on October 17. Disclosure followed within a day or so, which is fast by the standards of these events.
Fast disclosure doesn't mean the window was short. What's missing is when the legacy system was first breached, how long the attacker had access before that timestamp, and how many keys were pulled.
OpenCode says it's working with Anthropic, OpenAI, and Google to revoke the affected credentials. Provider-side revocation is the right move, because it kills the credential at the source instead of trusting a vendor to police usage after the fact. It also means some users will see requests fail before they ever read the email.
What OpenCode still won't say
Three gaps stand out, and all three matter to anyone doing incident response on their own account.
The company hasn't published how long the attacker operated inside the legacy system. It hasn't given a count of stolen keys, only a percentage of users. And it hasn't released indicators of compromise, which would let security teams check their own logs for signs of the same traffic.
None of those omissions is unusual a few days into an incident. They do mean the current picture is a floor, not a ceiling.
There's also the structural question nobody has answered. A system being retired still held live credentials for three major providers. That's a decommissioning problem, and it usually comes from credentials outliving the service that needed them.
What OpenCode users should do with their API keys today
If you connected a provider account to OpenCode Console, assume the key is burned. Rotate it.
Revoke first in the provider dashboard, then issue a new one. Rotation without revocation leaves the old key alive.
Then check usage graphs and billing for the period after October 17. What counts as a spike? Volume that doesn't match your traffic, requests from regions you don't operate in, or spend on models you never call. Detection is where most credential theft gets caught, and a bill that triples in a week while nobody shipped anything new is the plainest signal you'll get.
Third, update every app and script that used that key. A rotated key breaks anything still holding the old string, and discovering that during a deploy is worse than discovering it now.
The broader habit is worth adopting regardless of this incident. Long-lived keys stored in someone else's workspace are a standing liability, and scoped, short-lived credentials shrink the damage when a vendor's legacy system turns out to still be holding them.
OpenCode's next update will be the one to watch. A timeline, a key count, and a set of indicators would turn a percentage into something users can actually check against their own logs.






