Cursor Security Incident: Fireworks, Agent Traces, Key Rotation

Cursor's November 13, 2026 investigation explains how a Fireworks-exposed access key led to historical coding-agent traces, downstream SaaS access, and malicious Claude Code extension builds. Check whether your traces or workstation were affected, rotate credentials according to exposure, configure Privacy Mode, and keep runtime secrets outside agent conversations.

Contents
Cursor Security Incident: Fireworks, Agent Traces, Key Rotation

Cursor’s November 13, 2026 security incident report traces an attack from a Fireworks-exposed access key through historical coding-agent traces to a compromised extension cache. If Cursor notified you about exposed credentials, rotate them; if you installed affected Claude Code extension builds on October 29, follow Cursor’s host-remediation notice rather than simply uninstalling. For future coding sessions, enable Privacy Mode and give applications credentials through a trusted runtime instead of pasting them into agent conversations.

The practical lesson extends beyond Cursor. An API key pasted into a coding-agent conversation can become part of stored conversation history, tool output, or training data. If another system later exposes that record, the credential can remain useful to an attacker long after the original task ends.

What happened: From a Fireworks key to a malicious extension

Cursor’s November 13 report connects four stages of the incident.

  1. A vendor access key was exposed. An attacker obtained an access key Cursor had issued to Fireworks, its training and inference provider. Cursor says Fireworks exposed that key. The attacker used it to copy a read-only storage bucket that Cursor shared with Fireworks.

  2. Historical agent traces contained credentials. The bucket held a limited collection of coding-agent traces, mostly from 2025. These sessions were outside Privacy Mode and were permitted to be used for model training. Some traces contained API credentials that had not been redacted.

  3. Exposed credentials enabled further access. The attacker used credentials from those traces to access selected SaaS services used by Cursor. These systems exposed archived non-production Cursor source repositories, limited customer support records, email conversations, contact details, product usage metrics, conversation summaries, and some credentials previously sent to support.

  4. A stolen internal credential reached the extension cache. On October 29, the attacker used a credential obtained from exposed internal data to place malicious copies of Anthropic’s Claude Code extension in the cache serving Cursor’s VS Code extension marketplace.

The initial bucket was read-only, but that restriction did not stop an attacker with read access from copying its contents. Later access to internal SaaS services expanded the incident beyond the original historical traces.

Cursor reports that fewer than 0.01% of its customers had API credentials exposed. That figure describes credential exposure, not all data accessed during the incident.

The extension stage had a different potential impact. Cursor estimates that at most 5,000 users who requested particular cached extension versions on October 29 could have received a malicious build. The affected cache served the unauthorized copies for approximately 11 hours.

Anthropic did not publish those builds. Cursor says the upstream Open VSX marketplace never contained this malware. Cursor also says the incident did not exploit a vulnerability in Anthropic’s product.

What does Fireworks confirm?

Fireworks also published an October 2026 security bulletin and a November 9 investigation update.

Fireworks disclosed unauthorized use of internal credentials and subsequent findings involving stored secrets and some customer datasets. Its November 9 update says its investigation remains ongoing.

Those bulletins provide independent evidence of a Fireworks security incident. The specific sequence linking Cursor’s vendor key, historical traces, SaaS access, and the extension cache comes from Cursor’s own investigation.

The two companies’ reports should not be treated as interchangeable incident scopes.

Was your Cursor data affected?

There are two separate exposure questions: whether historical agent data was copied and whether your computer received a malicious extension.

Cursor’s November 13 report provides the following boundaries as of November 15, 2026.

Data or systemReported impact
Historical agent traces without Privacy ModeTraces from fewer than 0.05% of users outside Privacy Mode were exposed. Cursor says every identified user was notified.
API credentials inside those tracesFewer than 0.01% of Cursor customers had exposed API credentials.
Prompts and code under Privacy ModeCursor says these were not affected by the disclosed trace exposure.
Current prompts, code, and live inference requestsNot affected by the historical offline-storage exposure, according to Cursor.
Customer code repositoriesCursor reports no exposure of customer repositories.
Cursor production infrastructure and official app updatesCursor reports no compromise of production systems, official application releases, or release-signing keys.
Claude Code extension marketplace cacheSpecific malicious extension builds were served during the October 29 window.

Cursor says that if you received no notification, your data was not among the identified exposed historical traces. It contacted affected customers and team administrators through email or in-app notices.

However, not receiving a trace-exposure notice does not replace the extension check. The extension incident involves a separate exposure path: installing a malicious package during a specific period.

The percentages also have different denominators. The 0.05% figure concerns historical trace exposure among users without Privacy Mode. The 0.01% figure concerns customers whose API credentials were exposed. Neither figure is an estimated infection rate for the malicious extension.

How to enable Cursor Privacy Mode

Enable Privacy Mode before sharing additional project context with Cursor.

  1. Open Cursor Settings.
  2. Select General.
  3. Turn on Privacy Mode.
  4. Confirm that the setting remains enabled on the account you use for sensitive work.

These are the steps in Cursor’s current Privacy and data documentation.

For teams, Cursor says Privacy Mode is enabled by default. Administrators can enforce it at the organization level:

  1. Open the Cursor team dashboard.
  2. Go to Settings.
  3. Enable Privacy Mode for the team.
  4. Enforce the setting so members cannot disable it.

Cursor documents these controls under Privacy and Data Governance.

Privacy Mode prevents your code from being used for model training under Cursor’s stated policy. It does not mean your code never leaves your computer. Cursor still sends relevant prompts and context to model providers to process requests.

There are also separate data-handling rules for some features. For example, Cursor says its zero-data-retention arrangements do not apply when you use your own API keys. In that situation, the selected provider’s data policy applies.

Privacy Mode is therefore an important control, but it should not be your only credential-protection measure. It also cannot retroactively invalidate an API key exposed in an earlier conversation.

Installed Claude Code 2.1.312 or 2.1.313? Check your computer

Cursor’s original security notice, published October 29 and updated October 30, identifies the affected extension packages as:

  • Extension ID: Anthropic.claude-code
  • Versions: 2.1.312 and 2.1.313
  • Platforms: macOS and Windows
  • Distribution: Cursor VS Code Extension Marketplace
  • Exposure window: October 29, 2026, approximately 2:27am to 1:35pm PT

A version number alone does not establish compromise. The affected distribution source, platform, installation time, and package indicators matter.

The malicious code attempted to install an SSH backdoor. It collected host information, attempted to add an attacker-controlled SSH public key, and established persistence through operating-system startup mechanisms.

Cursor says enabling the local SSH service requires administrator privileges, which the malicious extension lacked on most macOS and Windows hosts. This permission requirement limited that part of the attack. Nevertheless, the malicious extension could leave files and persistence scripts behind.

Check the SSH indicator

One published indicator of compromise is an unauthorized SSH key marked svc-telemetry.

On macOS, use Bash in a trusted terminal:

if grep -qs 'svc-telemetry' "$HOME/.ssh/authorized_keys"; then
  echo "IOC found: isolate and investigate"
else
  echo "SSH marker not found: check other IOCs"
fi

On Windows, use PowerShell:

$files = @(
  "$HOME\.ssh\authorized_keys",
  "C:\ProgramData\ssh\administrators_authorized_keys"
) | Where-Object { Test-Path $_ }

if ($files -and (Select-String -Path $files -Pattern 'svc-telemetry' -Quiet)) {
  "IOC found: isolate and investigate"
} else {
  "SSH marker not found: check other IOCs"
}

These checks adapt the SSH indicator published by Cursor. They search for one known marker and do not perform a complete compromise assessment.

A negative result does not rule out the other published indicators. Cursor’s notice also provides malicious VSIX hashes, network indicators, suspicious processes, files, and persistence locations.

What to do if you installed an affected build

Follow Cursor’s full extension security notice, including its platform-specific scripts and indicators.

The response depends on what your investigation finds:

  1. Preserve evidence and check indicators. Review extension installation history, endpoint telemetry, network logs, and the published package hashes. Use the official validation instructions.

  2. Isolate an affected workstation. If you find signs of payload execution or backdoor installation, disconnect the host from sensitive systems and investigate its activity.

  3. Remove persistence, not only the extension. Cursor provides remediate-macos.sh and remediate-windows.ps1 in the notice. Download them from Cursor’s official page, review them, and follow the platform instructions. The scripts are designed to return a non-zero exit status if malicious components remain.

  4. Assess whether the machine needs rebuilding. Treat evidence of unauthorized access as a host security incident. Removing known files does not prove every possible attacker change has been identified.

  5. Rotate accessible credentials and sessions from a trusted computer. Include API tokens, cloud credentials, SSH access, and other authentication material available to the affected account or workstation.

Cursor explicitly warns that uninstalling the extension may leave standalone persistence scripts running. It also warns that limited environment-variable collection does not exclude later credential access through an installed backdoor.

Do not provision new production keys on a machine that may still be compromised.

This host-remediation process is distinct from rotating an API key found in a historical agent trace. A developer could need either response, both responses, or neither.

Which API keys should you rotate now?

Prioritize credentials by evidence of exposure and the access they grant.

SituationRecommended action
Cursor identified your exposed API credentialsRevoke or rotate the exact keys in the notification. Update every application using them.
You sent credentials to Cursor support and received an affected-data noticeRotate the identified credentials and check associated service activity.
You installed a potentially malicious extension during the affected windowInvestigate the workstation first. Rotate credentials accessible from an affected host using a trusted system.
You previously pasted a live key into a non-Privacy Mode agent conversationTreat the key as unnecessarily exposed. Rotate it, especially if it grants production or broad access. This does not mean Cursor confirmed your trace was stolen.
You used Privacy Mode and received no incident noticeCursor reports those prompts and code were outside this trace exposure. Continue normal credential hygiene rather than assuming every key was compromised.

For an exposed credential, deleting its text from a conversation is not sufficient. The issuing service must invalidate the old credential.

A practical rotation sequence is:

  1. Identify the issuing provider, affected applications, permissions, and last known uses.
  2. Revoke an actively abused or high-risk credential immediately. For other credentials, plan a controlled replacement without leaving the old credential active indefinitely.
  3. Issue a replacement with the minimum required permissions and a short expiration period where supported.
  4. Store the replacement in your application runtime or secret manager, not an agent chat.
  5. Update the affected applications and verify that they work with the replacement credential.
  6. Explicitly revoke every old credential that you have not already revoked. Creating and testing a replacement does not automatically invalidate the previous credential.
  7. Confirm the old credential is invalid. Review provider access logs, usage charges, and active sessions for unauthorized activity.

Use provider-specific procedures for database passwords, cloud service accounts, SSH keys, and API tokens. Some credentials require additional session revocation or investigation.

GitHub’s secret scanning documentation recommends rotating exposed credentials promptly. Its personal access token guidance also supports limited repository access, granular permissions, expiration dates, and explicit token deletion.

For a more detailed incident response covering GitLab, AWS, SSH, and VPN access, use the guide to secrets leaked into AI agents.

How to let a coding agent use an API without seeing your key

The safest default is to separate the agent’s code-writing role from the application’s secret-bearing execution environment.

The agent can write source code that reads a named environment variable. You or your deployment system then provide the actual credential outside the agent conversation.

Consider an agent building a small Python program that authenticates with the GitHub API.

1. Let the agent write credential-free code

Ask the agent:

Write github_auth_check.py using Python’s standard library. Read GITHUB_READ_TOKEN from the environment. Call GET https://api.github.com/user and print only the authenticated username. Never print or log the token. Do not open local credential files.

The resulting file can use the following code:

import json
import os
from urllib.request import Request, urlopen

token = os.environ.get("GITHUB_READ_TOKEN")
if not token:
    raise SystemExit("GITHUB_READ_TOKEN not set")

request = Request(
    "https://api.github.com/user",
    headers={
        "Authorization": f"Bearer {token}",
        "Accept": "application/vnd.github+json",
        "User-Agent": "local-auth-check",
    },
)

with urlopen(request, timeout=10) as response:
    user = json.load(response)

print("Authenticated GitHub user:", user["login"])

The code contains the variable name, endpoint, and authentication mechanism. It does not contain a credential.

GitHub’s REST API reference documents this endpoint. A fine-grained personal access token can use it without additional permissions.

2. Supply the token outside the agent session

Create a suitable short-lived token using your provider’s account controls.

For this example, open a trusted Bash terminal that is not controlled by the coding agent. Enter the credential interactively:

read -rs GITHUB_READ_TOKEN && export GITHUB_READ_TOKEN
python3 github_auth_check.py
unset GITHUB_READ_TOKEN

The read -rs command accepts input without displaying it. The Python process receives the variable from its environment.

A successful request prints:

Authenticated GitHub user: your-username

If authentication fails, check the token’s validity and provider permissions in the trusted environment. Do not paste the token into an agent conversation to troubleshoot the error.

The same separation applies to other APIs. Have the agent implement credential lookup, authentication headers, and response handling without supplying a real secret during code generation.

3. Keep execution permissions narrow

Environment variables reduce the chance that secrets appear in prompts or source files. They are not a security boundary against software that can inspect the process environment.

If you start a coding agent from a shell containing exported secrets, the agent or its child processes may inherit them. An agent with unrestricted terminal access may also read files or execute commands that expose credentials.

Use these boundaries:

  • Let the agent test with mock responses or non-sensitive test credentials.
  • Supply real credentials only to the specific trusted process that needs them.
  • Keep production secret files outside agent-readable project context.
  • Avoid terminal commands that print environment variables or dump secret files.
  • Use a secret manager or managed runtime injection for deployed applications.
  • Require approval for sensitive tool execution and restrict network access where possible.

When an autonomous agent genuinely requires an API credential, issue a dedicated temporary credential with tightly scoped permissions. Run the agent in an isolated environment and revoke the credential when the task ends.

This limits the impact if the agent, a tool, or an extension exposes the credential. It does not make an untrusted agent safe to run with unrestricted production access.

A team checklist for protecting coding-agent secrets

The following checks help prevent the same class of failure, whether you use Cursor, Claude Code, Codex, or another coding assistant.

  • Check incident notifications. Review Cursor account notices and team-admin email. Investigate extension installations separately from historical trace notifications.
  • Enforce Privacy Mode. Verify each developer’s active Cursor account and apply team-level enforcement for sensitive repositories.
  • Audit agent conversations and support tickets. Identify credentials deliberately pasted into prompts or exposed through tool output. Rotate active, sensitive credentials.
  • Minimize token privileges. Use separate development and production identities, limited resource access, short expiration periods, and automated revocation where supported.
  • Separate agents from secret stores. Keep production credentials out of shared agent instructions, project documentation, debug logs, and tool-visible files.
  • Check persistent agent memory. Summaries and long-term memory should retain technical decisions, not credentials. Apply the same review when using memory tools for coding agents.
  • Scan repositories and CI output. Enable available secret-scanning and push-protection controls. Remember that repository scanning does not automatically inspect private agent histories or every SaaS log.
  • Prepare a workstation response. Record how developers isolate compromised hosts, revoke sessions, rotate credentials, and verify that persistence is removed.

Cursor says it has moved inference traffic away from Fireworks, revoked the vendor’s access, rotated internal credentials, expanded secret scanning, and rebuilt its extension marketplace. It reported that the last observed attacker activity, on November 1, was blocked.

Those actions address parts of the disclosed incident. They do not replace a developer’s responsibility to revoke a credential that was exposed in an agent conversation or stored in an accessible workstation environment.

The reusable workflow is straightforward: let agents handle code and non-sensitive context; let trusted runtimes handle credentials. When a secret crosses that boundary, treat rotation as a credential-management task, not a chat-cleanup task.

Ready to optimize your LLM workflow?

Join thousands of developers building faster, smarter, and more cost-effective AI applications with BetterToken.

Get Started for Free