Cursor's breach began with keys left in agent tracesYour vendors hold copies of your keys
On November 13, 2026, Cursor said its October breach started with an access key stolen from Fireworks, which opened a bucket of agent traces that still held customer credentials. The same month, attackers pulled stored keys out of Railway, OpenCode and Fireworks itself. Every copy of a key you hand a vendor is a key you have to rotate when that vendor falls.
-
01
Source
Vendor key
A Cursor access key held by Fireworks is exposed in a Fireworks incident
October 2026 -
02
Channel
Trace bucket
Read-only bucket of 2025 agent traces, some with unredacted credentials
non-Privacy Mode -
03
Exposure
SaaS and cache
Support data, repos, then a tampered extension served for 11 hours
contained Nov 1
TL;DR· the answer, in twenty seconds
What happened: An attacker used a Cursor access key exposed at Fireworks to copy a bucket of coding agent traces. A few traces held unredacted credentials, which led to Cursor's SaaS tools, credentials users had sent to support, and the tampered Claude Code extension builds served on October 29.
The minimum fix: List every vendor that holds a copy of each provider key, including traces, hosted consoles, deploy platforms and support tickets. Rotate keys whose holder disclosed a breach, then bind each new key to the network it runs from and cap its spend.
The lesson: Redaction and vendor promises decide how many copies of a key exist. A key that only works from your egress range and your budget stays cheap to lose, whoever leaks it.
Cursor's November 13 incident update traced its October breach to a single access key that Cursor had issued to Fireworks, the inference and training vendor, and that Fireworks lost. The attacker used it to copy a storage bucket of coding agent traces, and a few of those traces contained live credentials that no redaction step had caught. Those credentials opened Cursor's own SaaS tools, and a credential found there let the attacker plant the tampered Anthropic.claude-code 2.1.312 and 2.1.313 builds that Cursor's marketplace cache served on October 29.
If you read the October 30 notice and our recovery guide, you already know the endpoint half of this story. The update fills in the start, and the start is the part most teams can do something about. The credentials in those traces came from users. They reached Cursor's training data because an agent saw them during a session, and they reached an attacker because a second vendor held a key to that data.
Cursor was one of several breached vendors that month. Wiz called the run of incidents "Black October" and counted inference vendors, deploy platforms and hosted agent consoles among the victims. In every case with details so far, the attacker went after stored credentials that belonged to customers.
The chain Cursor described on November 13
The update gives the sequence in five steps. Cursor's wording matters here, so the summary below stays close to it.
- An attacker obtained an access key that Cursor had issued to Fireworks. Cursor says the key was "exposed by Fireworks" and links to the Fireworks security bulletins. It does not say which of the two Fireworks incidents exposed it, and SecurityWeek reports it as "one of these incidents."
- The key could read a storage bucket Cursor used to share data with Fireworks. It held limited coding agent traces, most of them from 2025, from sessions that were not in Privacy Mode and that Cursor was permitted to use for model training. BleepingComputer reports Cursor's figure that fewer than 0.05% of users had traces exposed.
- A small number of traces contained credentials that had not been redacted. Fewer than 0.01% of customers had API credentials exposed this way.
- With those credentials the attacker reached select SaaS tools Cursor uses. From there they took archived non-production source repositories, limited support data and email conversations, product usage metrics and contact details, summaries of some agent conversations, and "some credentials users had sent to the Cursor support team."
- A credential taken from those systems let the attacker place the two tampered extension builds on the cache that serves Cursor's VS Code extension marketplace. Cursor puts the exposure at about 11 hours and at most 5,000 users. The Open VSX source was clean.
Cursor published the security notice on October 30 and says it has seen no attacker activity since November 1. It lists what stayed out of reach: Privacy Mode data, its production infrastructure, the app and its official updates, and release signing keys, since Cursor ships from a separate code host the attacker never touched.
The remediation list is short and specific. Cursor moved all inference off Fireworks. It rotated every exposed credential it found, highest risk first, and then every credential in use across its internal systems. It added secret scanning to all its repositories and widened it to other internal data sources. It also expanded network access restrictions across its service providers, "where possible, so compromised credentials can't be used outside their intended location." Keep that last item in mind. It is the only control on the list that would have helped before anyone knew the key was gone.
Two kinds of customer data in this chain deserve attention.
The traces held credentials because an agent saw them. A developer pasted a key into a prompt, or the agent read a .env file, ran printenv, or printed a config while debugging. The session then became training data under the terms the user had accepted. Redaction ran, and it missed some. A redactor matches known key formats, and anything that does not look like a key passes through: a database URL with a password in it, a webhook with a signed query string, an internal token with no prefix.
Support tickets held credentials because people sent them. Someone debugging a failed integration attaches the token to the ticket so support can reproduce the problem. That ticket now lives in a helpdesk SaaS, indexed and searchable, for as long as the vendor keeps tickets. Cursor had no reason to store those credentials, and the attacker found them anyway.
Black October: every vendor held someone else's keys
Wiz published its round-up on October 30, before Cursor's update. Its summary of the public reports is blunt: they "highlight targeted exploitation, explicitly hunting stored environment variables, with a focus on those granting AI access." Wiz also notes that no single vulnerability or dependency links the attacks. The common thread is what the attackers wanted.
The table covers the four incidents with the most published detail. Dates come from the vendors' statements as reported.
| Vendor | First access | What the attacker took | Customer secrets involved |
|---|---|---|---|
| Fireworks (first incident) | October 6, internal credentials | Environment variables in evaluation jobs | API keys and tokens stored as secrets for a limited number of accounts |
| OpenCode Console | Earliest exposure October 17, 00:30 UTC | Stored provider keys, through what Wiz reports OpenCode calls a legacy system | Keys for linked external providers, 1.4% of Console users |
| Railway | October 20, build infrastructure escape | Internal source code, then decrypted customer environment variables | At most 1.85% of workspaces, about 100,000, plus linked tokens for 1,852 users |
| Fireworks (second incident) | October 23, third-party cloud provider | Resource metadata, billing data, incomplete model weights and datasets | Customer datasets, including Notion AI chat transcripts |
The details differ. The shape repeats.
The Register reports the first Fireworks incident began with unauthorized use of internal credentials on October 6, and that attackers reached environment variables in evaluation jobs holding customer API keys and tokens. Fireworks linked the group to LLMjacking, the resale of stolen model access, according to BleepingComputer. The second incident began when a third-party cloud provider hosting Fireworks R&D machines was breached on October 23. The attacker reached Fireworks development machines the next day.
At OpenCode, the hosted Console stored keys users had linked for Anthropic, OpenAI and Google. BleepingComputer reports that OpenCode called it a "large-scale distillation attack" affecting 1.4% of Console users, that some users reported more than $1,700 in unauthorized charges overnight, and that some saw Google Cloud projects suspended for abusive activity. The report concerns keys linked in the hosted Console. A key that lived only in a developer's local environment was not among the values the Console stored.
Railway's write-up, as BleepingComputer reports it, is the most detailed. On October 20 the attacker used an unknown flaw in Railway's build infrastructure to escape filesystem isolation and take an internal credential. That credential exposed stored build histories and a copy of Railway's source code. The attacker read the code, found a misconfigured trust relationship, and used it to get the credentials that decrypt customer environment variables. Railway describes a fight of about 26 hours against an attacker running AI agents along many routes at once. It says the attacker searched for AI provider credentials first, with some queries aimed at cloud, database and payment credentials. The stolen keys produced about $740,000 in unauthorized AI usage.
Notion is the case where the vendor had promised not to keep the data. BleepingComputer reports that Fireworks had committed in its contract to zero data retention for Notion data. Fireworks alerted Notion on November 2 about an exposed dataset it described as synthetic test data. Notion cut traffic to Fireworks and deleted its data from Fireworks systems by November 3. On November 8, Fireworks confirmed that customer data had been accessed, and Notion found the dataset held AI chat transcripts from its Insights feature. Notion now tells affected users to rotate any passwords, API keys or other credentials typed into those chats.
The lesson from Notion applies to Cursor too. A retention clause tells you what the vendor plans to do. It does not tell you where copies sit when the vendor's own vendor gets breached.
What a stolen AI key buys an attacker
Wiz followed two stolen AWS keys that it ties to one of the vendor breaches. Both had seen heavy use from the compromised vendor's infrastructure before the breach. The timelines show how long you have and what slows an attacker down.
The first use of both keys was a single InvokeModel call from a residential IP address, part of a one-minute sweep that tested stolen keys across several organizations. For days after that, each key saw 14 to 120 calls a day from the same small Go client, about a minute apart, which Wiz reads as a job checking that the keys still worked.
The first key had no network restriction. Four days after validation, a rotating proxy pool sent one call per model across vendors to see what the key could reach. A few hours later a script mapped Bedrock and EC2 quotas, and bulk traffic began 22 seconds after that. Over 30 hours the actor made about 800,000 Bedrock calls, and about 90% succeeded. The key's policy allowed cross-region inference profiles, so the load spread across regions and only about 6% of calls hit a throttle.
The second key was restricted. Its policy allowed Bedrock only through specific cross-region inference profiles. Seven days after validation it surfaced in what looked like a reseller pool, and for four hours thousands of calls failed because the pool requested the wrong profiles. Then a checker found the profile that worked, and one hosting address made about 1.7 million calls over 13 hours, more than a million of them successful. Without global routing, the rest ran into regional quotas.
Read those two cases as a test of controls. The restriction on the second key cost the attacker four hours and some confusion, then failed, because it limited which models and regions the key could reach and said nothing about where the caller was. Regional quotas slowed it more than the policy did. Neither key had a condition tying it to the vendor's network, which would have made both worthless once they left it.
Wiz's timeline also shows the gap between theft and abuse. Both keys sat in a checker for days before bulk use. A team that rotated on the day its vendor disclosed would have beaten the bulk traffic in both cases.
Find the copies of your keys that live on vendor servers
You cannot rotate copies you do not know about. Before you touch any key, write down every place a copy of it might live. For each provider key, the places to check fall into a few groups.
Agent traces and transcripts come first. Any hosted coding agent that stores sessions, and any whose terms let it train on sessions outside a privacy setting, may hold whatever the agent saw. For Cursor, check whether Privacy Mode was on for each account during 2025. If it was off and the account appears in Cursor's notice, treat every key that account's agents touched as exposed. Cursor says it emailed team admins a list of specific keys to rotate, so look for that email first. The sweep guide covers the local copies of the same transcripts.
Hosted consoles and platforms come next. That means anything where you pasted a provider key so the vendor could call the model for you: OpenCode Console, inference vendors, eval platforms, deploy platforms with environment variables. Railway's encrypted variables still came out decrypted, because the attacker reached the credentials that do the decryption.
Then check support threads and email. Search your sent mail and your helpdesk exports for tokens you shared while debugging an integration. Cursor's update names this category, and every vendor's support system works the same way.
Last, check vendor-issued keys that point back at you. Cursor's breach started with a key Cursor gave Fireworks. If you share a bucket, a database or an API with a vendor, the vendor holds a key to your data, and its breach becomes yours.
A plain file keeps this honest. Put it in a private repo and update it when you add a vendor:
# key-copies.yaml: one entry per credential, one line per copy
anthropic-prod:
owner: platform-team
copies:
- holder: local developer machines
how: env file loaded by direnv
- holder: cursor (agent traces, 2025)
how: pasted into sessions, Privacy Mode off
action: rotate, Cursor notice lists this team
- holder: opencode console
how: linked as external provider
action: rotated 2026-10-19, unlinked
restrictions:
source_ip: 203.0.113.0/24
monthly_cap_usd: 2000
aws-bedrock-ci:
owner: ml-infra
copies:
- holder: ci runners
how: OIDC role, no static key
- holder: eval vendor
how: static access key in vendor env vars
action: replace with vendor-specific key bound to vendor egress
The file has two jobs. During an incident, it turns "which keys do we rotate" into a lookup. Between incidents, it shows you copies that should not exist, such as the same production key at three vendors.
Make a stolen key fail somewhere else
Rotation fixes the past. A network condition limits the next leak, and it is the control Cursor added after the fact.
Give each vendor its own key so that one breach means one rotation. Then bind each key to the network it should come from. On AWS, a deny statement on the principal does this. The example below blocks Bedrock model calls from any address outside your egress range unless an AWS service makes the call on your behalf:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DenyBedrockOutsideEgress",
"Effect": "Deny",
"Action": [
"bedrock:InvokeModel",
"bedrock:InvokeModelWithResponseStream"
],
"Resource": "*",
"Condition": {
"NotIpAddress": { "aws:SourceIp": ["203.0.113.0/24"] },
"Bool": { "aws:ViaAWSService": "false" }
}
}
]
}
The Converse API checks the same bedrock:InvokeModel permission, so this statement covers it as well. Requests that arrive through a VPC endpoint carry no public source IP, so callers inside a VPC need an aws:SourceVpce or aws:SourceVpc condition instead. Test the policy from inside and outside the range before you rely on it, since a deny with the wrong range breaks production.
For a key a vendor uses, ask the vendor for its egress ranges and bind the key to them. If the vendor cannot give you stable ranges, that tells you how far its key can travel when it leaks. Against Wiz's two cases, this condition would have stopped the residential sweep, the proxy pool and the hosting address alike.
Model providers that issue their own API keys offer fewer network controls than AWS IAM does. Use what they have: a separate project or workspace per vendor, a spend limit on each, and usage alerts that fire on volume. Wiz's second key went from zero to more than a million successful calls in 13 hours. A monthly cap sized to normal use would have ended that run long before the millionth call, and an alert on calls per hour would have paged someone before the cap hit.
Then rotate the day the vendor discloses, before you confirm abuse in your own logs. Railway disclosed on October 22 and asked customers to rotate. The second Wiz key waited seven days in a checker before bulk use. Teams that rotated the day of the notice were ahead. Teams that waited to confirm abuse in their own logs were behind.
Fix the sources of new copies last, since they keep producing them:
- Keep keys out of agent sessions. An agent that never sees a value cannot write it into a trace. Load each key into the process that needs it, keep it out of the shell the agent drives, and never paste one into a prompt.
- Turn on the privacy setting that keeps sessions out of training for every account that touches production credentials, and check it per account rather than per team.
- Never send a live credential to vendor support. Send a scoped, short-lived one, or the error output with the token removed, and revoke whatever you sent when the ticket closes.
- Prefer platforms that call your secret store at run time over platforms that ask you to paste the value into their settings.
What this means for your stack
Do two things this week. Check whether Cursor or any Black October vendor emailed your team, and rotate every key on the list. Then write the copy inventory for your production model keys, give each vendor its own key, and put a source-IP condition and a spend cap on every key that supports them.
The pattern behind most of these breaches is a long-lived key stored in a place you do not control: a trace, a console, an environment variable on someone else's platform, a support ticket. Two changes shrink it. Fewer copies come from keeping values out of anything an agent or a vendor records. Cheaper copies come from binding each key to where it runs, so a stolen one fails on the attacker's network.
hasp is one working implementation of the first half, on your own machine. After hasp setup, hasp run --project-root . --env ANTHROPIC_API_KEY=@ANTHROPIC_API_KEY --grant-secret window --grant-window 15m -- npm test gives the key to that test run, so the command the agent writes, and any trace built from it, holds a name instead of the value. It does nothing for a key you paste into a hosted console, and its threat model does not cover a malicious process running as the same user. Source-available (FCL-1.0), local-first, macOS and Linux, no account.
Cursor's redaction worked on most traces and Fireworks had a retention promise with Notion. Neither stopped the keys that slipped through. Count the copies, and make each one fail away from home.
Sources· cited above, in one place
- Cursor Security incident update
- Cursor Security notice: malicious version of Anthropic.claude-code (2.1.312 and 2.1.313) identified in the Cursor VS Code Extension Marketplace
- BleepingComputer Cursor confirms security breach led to malicious Claude Code extension
- SecurityWeek Cursor Supply Chain Attack Started at Fireworks AI
- The Register Fireworks AI gets burned twice as customer data exposure widens
- BleepingComputer Fireworks AI discloses new breach after cloud provider hack
- Wiz “Black October” for AI Developer Platforms
- BleepingComputer Railway breach leads to $740,000 in fraudulent AI charges
- BleepingComputer OpenCode hack exposes API keys amid AI distillation attacks
- BleepingComputer Notion says Fireworks breach exposed customer AI chat transcripts
Stop handing the agent your real keys.
hasp keeps secrets in one local encrypted vault, brokers them into the child process at exec, and never lets the agent read the value.
- Local, encrypted vault — no account, no cloud, no telemetry by default.
- Brokered run — agent gets a reference, the child process gets the value.
- Pre-commit + pre-push hooks catch managed values before they ship.
- Append-only HMAC audit log answers "did the agent touch the prod token?" in seconds.
macOS & Linux. Source-available (FCL-1.0, converts to Apache 2.0). No account.