OpenCode reports a security breach affecting 1.4% of its Console users, specifically a subset with external providers linked. The latest edited notice says those users were emailed and the incident is ongoing. For API key security, the useful first question is which component holds the credential. A familiar product name can hide several different answers.
TL;DR
- The reported percentage is of Console users. Installing the local OpenCode agent alone does not establish inclusion in the affected group.
- Console's documentation says it stores connected provider credentials and serves requests through a shared gateway. That is the documented architecture; the incident's access path remains undisclosed.
- Review the official notification and provider activity. Preserving evidence, revoking suspicious credentials and updating affected integrations are general incident-hygiene advice.
- “Distillation” describes an alleged purpose involving model outputs. The public notice leaves the attacker identity, full customer impact and completed fix open.
- Sphinx and Pele, two other fresh developer tools, have useful documented boundaries of their own. Read those before adopting either one.
OpenCode Console breach: what the statement actually establishes
The original announcement linked from Hacker News has a newer edited version. The newer statement matters because it spells out a condition that changes how a reader interprets the incident: the affected users had external providers linked. The same statement says OpenCode notified them by email and that users who did not receive an email were not impacted. That is the company's current affected-user claim. It should remain attributed to the company when repeated.
The 1.4% figure needs its denominator attached every time. The population is Console users. The notice does not supply the population's size, so it does not support an absolute victim count. It also does not support applying the percentage to all OpenCode installations, monthly users or GitHub followers. Multiplying two unrelated marketing numbers would make an impressive graphic and an inaccurate one.
The public statement says the team is working with Anthropic, OpenAI and Google to remediate. It says details cannot be shared yet because the incident is ongoing. Those are response statements. They leave several ordinary incident questions unanswered: how access was gained, what exact credential handling failed, how much unauthorized activity occurred and which changes will prevent a recurrence.
Individual replies about missing credit or unexpected usage deserve investigation. This article does not independently verify those reports, turn them into a loss total or promise reimbursement. There is no verified reimbursement commitment in the cited notice. A screenshot of somebody's bill would still need an account of what caused the change before it became an incident-wide fact.
We covered the initial announcement as an overnight side story in the previous episode. This is an explicitly requested follow-up, with more room for the scope and documented architecture. My earlier NEEDS REVIEW verdict remains a useful starting position while the technical report is missing.
API key security starts with a credential map
OpenCode's product page describes an open-source coding agent for the terminal, editor and desktop. The Console model documentation describes an optional provider that can be used with OpenCode or another coding agent. A person may use OpenCode with a different provider arrangement. The local agent's name therefore cannot establish whether the person used the affected hosted service.
The Console provider documentation supplies a concrete architectural fact: Console stores a connected provider credential and serves that provider through its gateway. Workspace members can use the models without seeing the upstream provider key. Owners and administrators manage these connections through the Providers tab.
That arrangement has an obvious administrative benefit. A team can share model access without copying an upstream key to every member. It also gives the gateway responsibility for a credential that unlocks an external service. The documented convenience and the documented trust boundary are part of the same design.
A useful inventory separates the pieces:
| Piece | Question to answer |
|---|---|
| Local coding agent | Which provider configuration does this agent use? |
| Hosted Console workspace | Which external accounts have been connected here? |
| Provider credential | Who can revoke it and where can its activity be inspected? |
| Downstream integration | Which tools depend on this credential being valid? |
This is an inventory template. It is not a reconstruction of the attack. Drawing an attacker moving along these boxes would imply knowledge the announcement has not supplied. The exact failure could involve a different part of the service, and the eventual report will have to explain that.
For the same reason, keeping the percentage narrow does not make the impact trivial. A subset can contain people with serious exposure. Scope helps those people find the right response and helps other readers avoid treating an unrelated component as a confirmed victim.
What to check when provider credentials may be exposed
Start with the official notice and your own account arrangement. Establish whether external providers were connected through Console. Review the notification the company says it sent. If something about your account remains unclear, use the official support channel and ask about that concrete configuration rather than trying to diagnose it from another person's reply thread.
Then review provider activity. Preserve the relevant timestamps and records before changing the credential arrangement, where that is practical and consistent with containing suspicious use. If you identify suspicious activity, revoke the exposed credential through the provider that issued it. Update affected integrations with a deliberate replacement rather than leaving a silently failing tool in the background.
These are general incident-response habits, offered as editorial advice. OpenCode's announcement has not published a complete customer remediation checklist. Follow any newer, account-specific instructions that the company and the affected provider supply. The live notice should be rechecked before this piece is published because an ongoing incident can change while a video is being edited.
For future integrations, record where a credential lives, which upstream account it reaches and who owns revocation. Restrict its permissions and spending where the provider supports that. Review activity and keep an inventory of dependencies that will need updating after a replacement. The exact controls depend on the provider and account type; a generic “rotate everything” slogan does not perform that inventory for you.
I would also distinguish the service's access controls from the agent's working permissions. A code-review hook, terminal prompt or confident model answer supplies a different kind of assurance. It does not establish the security of a hosted credential store. Developers already spend enough time asking whether a green badge means what they think it means.
What “distillation attack” tells us
Anthropic's background explanation defines distillation as training a less capable model on the outputs of a stronger one. The technique also has legitimate uses. A provider can distill its own models into smaller versions; unauthorized extraction campaigns use outputs for a different purpose.
OpenCode associates this breach with a large-scale distillation attack. The useful reading is that this describes the alleged purpose of the activity. It leaves the access mechanism open. The words do not identify an attacker, explain how credentials were handled or quantify what happened to customers.
Anthropic's February article discusses separate cases. Its named organizations and account totals must stay attached to those cases. They provide no attribution for this OpenCode incident. A story can have a plausible motive while still lacking a public technical cause, and the two should remain separate fields in the reporting.
The later report should help customers answer what changed in the system they actually used. Until then, an elaborate attack diagram would mainly demonstrate how well the illustrator can connect arrows.
Also today: Sphinx asks you to explain the diff
Sphinx is a Git hook that pauses protected-branch pushes for an understanding check. A separate reviewer reads the committed change without the generating chat. It asks about behavior and failure cases. Its published worker/redelivery conversation is illustrative; we have not installed Sphinx or measured a production-review improvement.
The adoption caveats deserve attention. Installation changes the global Git hook path. The reviewer provider receives changed code and answers. Filename-based exclusions cannot catch a secret embedded in ordinary source. There is no default cap on model calls; a typical check uses five to eight requests plus about one per answer. Local hooks can be bypassed, and the examiner can be wrong. This is an exercise in understanding with costs and data flow to inspect.
Also today: Pele changes the theme while keeping the SVG
Obsidian's kepano released Pele, a Mermaid-to-SVG renderer with CSS-variable theming. Its bundle table reports about 230 kB compressed against Mermaid's 1.6 MB. Speed comparisons remain the project's measurements; we did not reproduce them.
We did make a small behavior check in the real homepage editor. Changing the documented CSS variables preserved the same SVG node and four labels while the computed background and line colors changed. That demonstrates the advertised theme behavior, with no claim about render speed.
The security page says displayed images can make network requests, and the application owns supplied icon markup and internal-link navigation. Links and images can be disabled. Source/output limits are documented. A smaller dependency still arrives with responsibilities for its caller.
Verdict: NEEDS REVIEW
I'd keep the Console incident under review until enough information is published to assess the affected credentials and the fix. The practical habit is to identify which service actually holds your provider access. That information remains useful after the current headline leaves the front page.
FAQ
Does using the local OpenCode agent put me in the reported affected group?
Installation alone does not establish that. The official notice names a subset of Console users with external providers linked. Check your own provider arrangement and the company's notification.
Does 1.4% tell us how many people were affected?
The total Console population is undisclosed in the cited notice. An absolute count cannot be calculated from that statement alone.
Has OpenCode published the root cause or completed fix?
The reviewed notice says the incident is ongoing and additional details cannot yet be shared. It states that the team is working with three providers to remediate. It does not establish completion.
Will an AI understanding check secure my provider credentials?
A tool such as Sphinx asks a different question: whether you can explain a committed change. Its own documentation exposes reviewer limitations and data flow. Credential storage needs its own reviewed controls.
Sources
- Latest edited OpenCode notice
- OpenCode product
- Console provider gateway
- Optional Console models
- Distillation background
- Sphinx documentation
- Pele
- Pele security
- Pele maintainer explanation
This article expands on an episode of **The Daily Diff, a five-minute daily video on what shipped and what broke in tech.
Watch the episode · Subscribe on YouTube · the written diff lands in your inbox every morning at thedailydiff.dev.
