# The Cursor Security Incident: Your AI Coding Tool Is Part of Your Supply Chain

Author: Prateek Sharma
Canonical: https://www.prateek-sharma.com/blog/cursor-security-incident-ai-coding-supply-chain/
Published: 2026-11-17
Updated: 2026-11-17
Topics: Cursor, AI Coding Security, Software Supply Chain, Developer Security, Third-Party Risk, VS Code Extensions

AI coding security extends beyond generated code. What the Cursor incident exposed about traces, vendor credentials, extension delivery, and the systems engineers can reach.

**AI coding security extends beyond generated code. The Cursor security incident exposes the trust decisions connecting developer tools, retained traces, vendor credentials, extension delivery, and the systems engineers can reach.**


**TL;DR**

- Treat an AI coding tool as a supplier with access to engineering information and, depending on its configuration, execution capability.

- Review three connected surfaces: where engineering data travels, what software reaches developer machines, and which credentials those environments can use.

- Privacy settings, package integrity, endpoint controls, and access restrictions protect different boundaries. Evaluate them separately.

- Include historical traces, evaluation datasets, support uploads, extension caches, and subprocessors in the review.

- When investigating exposure, distinguish data disclosure, credential compromise, and malicious code execution. Each requires different evidence and response.

## What Cursor disclosed and what it means

An engineering team can review every line in a pull request and still miss a compromise arriving through the tool used to write it.

That is the uncomfortable architectural question raised by Cursor’s November investigation. AI-assisted development adds suppliers, data stores, and software distribution paths around an environment that already holds valuable access.

According to Cursor’s **13 November report**, an access key issued to Fireworks was exposed and used to copy historical coding-agent traces. Some contained unredacted credentials that enabled access to selected internal services. A stolen credential subsequently enabled malicious Claude Code extension copies to be placed in Cursor’s extension-serving cache. [Source](https://cursor.com/blog/security-incident-update)

Keep the reported boundaries precise:

| Question | Cursor’s account |
| - | - |
| How broad was potential extension delivery? | At most 5,000 users requesting particular cached versions may have received malicious builds, during roughly 11 hours on 29 October. |
| Was Anthropic’s product compromised? | Cursor says Anthropic did not publish the malicious copies and the incident was not an Anthropic product vulnerability. Open VSX did not contain the malware. |
| What did Cursor exclude? | Its official app releases, customer code repositories, active inference traffic, and Privacy Mode prompts and code. |
| What was the status? | Cursor said it believed the incident contained; the last observed attacker activity on 1 November was blocked. |

These are vendor-reported findings, current as reviewed on 15 November, rather than an independent forensic conclusion. [Full investigation](https://cursor.com/blog/security-incident-update)

The strategic implication extends beyond one vendor: **your development supply chain includes the services that observe engineering work and the systems that deliver engineering tools.**

## The supply chain now runs in both directions

The familiar software supply-chain question is what enters the product: packages, libraries, build images, and deployment artifacts.

AI coding tools add an outward-facing question: what leaves the engineering environment while software is being built?

Depending on the tool and settings, that can include prompts, selected source files, terminal output, diagnostic material, conversation history, and support attachments. Those data flows can coexist with an inward software flow through extensions, updates, plugins, and downloaded tools.

A reference map for enterprise review looks like this. It describes possible trust relationships, not a reconstruction of the Cursor attack.

<figure class="diagram" data-diagram="cursor-security-incident-ai-coding-supply-chain-1">
<img class="diagram__img diagram__img--light" src="/img/diagrams/cursor-security-incident-ai-coding-supply-chain-1-light.svg" width="955" height="606" alt="Flow diagram: Developer environment → AI coding service → Model and infrastructure providers → Traces and support records → Further service providers → Evaluation and analytics stores → Extension publishers → Distribution and caches → Repositories and build systems → Credentialed enterprise services" loading="lazy" decoding="async" />
<img class="diagram__img diagram__img--dark" src="/img/diagrams/cursor-security-incident-ai-coding-supply-chain-1-dark.svg" width="955" height="606" alt="Flow diagram: Developer environment → AI coding service → Model and infrastructure providers → Traces and support records → Further service providers → Evaluation and analytics stores → Extension publishers → Distribution and caches → Repositories and build systems → Credentialed enterprise services" loading="lazy" decoding="async" />
</figure>

The practical concern is the connection between these paths. Information disclosed through one service can contain access material for another. Software delivered through a familiar channel may execute in an environment with access far beyond the original purchase.

Reviewing the outward data path and the inward software path as unrelated procurement questions leaves that connection unexamined.

The US National Institute of Standards and Technology describes provenance in terms of a component’s origin, ownership, location, changes, and associated processes. That is a useful lens for engineering tooling: identify where an artifact came from, how it changed, and who could affect it before execution. [Source](https://csrc.nist.gov/glossary/term/Provenance)

A vendor name identifies one organization. A trust map identifies the boundaries your organization actually depends on.

## Historical traces can become a credential problem

A trace can be useful for debugging and still contain material that should never become a broadly accessible dataset.

Consider a failed deployment session. Its output might include an authorization header, a connection string, an environment dump, or a signed resource link. A support request might contain the same material because an engineer copied the console output while troubleshooting.

These are illustrative exposure paths. The relevant design question is whether your controls cover the places engineers and agents actually produce diagnostic data.

**A secret can outlive the task that exposed it.** Deleting the current conversation does not revoke a credential. Removing a log entry does not invalidate copies already made. Changing suppliers does not establish that historical exports, backups, and evaluation datasets have expired.

The Open Worldwide Application Security Project (OWASP) recommends managing secrets through their lifecycle, including restricted privileges, expiration, revocation, and auditing. It also describes short-lived dynamic credentials where feasible. [Source](https://cheatsheetseries.owasp.org/cheatsheets/Secrets_Management_Cheat_Sheet.html)

Apply that discipline to agent workflows. A coding agent that needs to run a test should not automatically inherit every credential available to an engineer’s interactive shell.

### Reduce exposure before relying on redaction

Use test identities and synthetic data where they satisfy the task. Avoid emitting secret values in ordinary diagnostics. Obtain scoped credentials at the point of use and limit their lifetime.

Then scan likely collection points: tool output, trace ingestion, support uploads, evaluation exports, and archives. Test the scanners with representative secret formats and transformations. A scanner’s presence is less informative than evidence that it catches the material your workflows generate.

Treat redaction as an additional control with known limitations. Restrict access and retention for the data that remains.

For each retained dataset, record its purpose, owner, permitted recipients, access mechanism, retention period, and deletion process. If nobody can answer those questions, keeping more history may create more uncertainty than diagnostic value.

## A trusted extension name is an incomplete control

An extension has at least three identities: the name users recognize, the publisher associated with it, and the exact package that a machine executes.

Enterprise controls need to connect all three.

Microsoft’s Visual Studio Code documentation states that its extension host has the same permissions as the editor, including the ability to read and write files, make network requests, and run external processes. That is a statement about VS Code’s documented runtime, not a claim that every editor or AI product has identical isolation. [Source](https://code.visualstudio.com/docs/configure/extensions/extension-runtime-security)

An extension review therefore belongs alongside other decisions about software running in the engineering environment.

### Verify the delivery path

Record the publisher, extension identifier, version, source marketplace, installed package, and relevant installation or update time. Where supported, validate package signatures and retain trusted package digests.

Microsoft documents signing and installation-time verification for extensions from the Visual Studio Marketplace. Those controls should not be assumed to apply identically to another marketplace, a mirror, a cache, a forked editor, or a manually installed package. [Source](https://code.visualstudio.com/docs/configure/extensions/extension-marketplace)

A package hash is useful only when compared with a trusted reference. A signature establishes integrity relative to its signing authority; it does not establish that the signed code is harmless.

An approved publisher list is useful, but it does not by itself validate every delivery layer between publication and execution. Ask how cached artifacts are verified and which identities can replace or serve them.

### Balance update speed and review

Freezing every extension indefinitely introduces its own risk by delaying fixes. Unrestricted updates provide little opportunity to detect a compromised release before broad deployment.

For sensitive engineering groups, use managed installation policies and a staged rollout appropriate to the tool’s access and release frequency. Keep a rapid emergency route for urgent security updates. Reassess packages when their permissions, publishers, delivery paths, or dependencies change.

Most importantly, keep an inventory that can answer a specific exposure question across the fleet. “We use this editor” is much less useful than knowing which machines installed a particular package through a particular channel.

## Privacy promises need a data-flow map

Three procurement questions are often collapsed into one:

- Can the vendor use our data for model training?

- What data is retained, for how long, and for what purpose?

- Which systems and service providers can access it?

They concern different controls. A contractual restriction on training does not describe every operational, support, or diagnostic data path. Likewise, a zero-data-retention commitment must be interpreted within its stated product, endpoint, and processing scope.

Fireworks’ **9 November bulletin** described impacts involving secrets, datasets, and incomplete models for a limited set of accounts. It separately said it had not detected impact to specified zero-data-retention services, with its investigation still ongoing. Those scope statements should remain separate rather than becoming a claim that all Fireworks services were affected or that retention controls are meaningless. [Source](https://fireworks.ai/security/bulletins/october-2026-security-incident-update)

Notion’s related advisory provides another relevant data-flow example. It said affected material included AI chat transcripts used for its Insights feature, and its 13 November update reported notifying credential issuers about exposed third-party application programming interface (API) keys found in affected messages. That is a separate customer disclosure, not evidence that Notion was part of Cursor’s extension-delivery chain. [Source](https://www.notion.com/en-gb/security/advisories/security-incident-involving-a-third-party-ai-vendor)

### Ask questions at the level of the workflow

| Data path | Question to resolve |
| - | - |
| Interactive inference | Which inputs leave the environment and which providers process them? |
| Diagnostics and traces | What is recorded, who can access it, and when does it expire? |
| Product analytics | Is content inspected, sampled, transformed, or exported? |
| Evaluation and training | Which datasets can be created, by whom, and under which agreement? |
| Support | What can staff request, retrieve, or attach to a case? |
| Backups and deletion | What is removed, what remains, and when do remaining copies expire? |

Have the vendor identify differences between features and plans. Confirm how organization-level settings apply to individual users, trial features, and newly added capabilities.

The goal is an answer your architects can map to the actual service. A general privacy assurance is too broad to settle each of these questions.

## Agent capability makes developer isolation more important

An AI agent can read context, invoke tools, execute commands, and change files when the surrounding environment permits those actions. That makes its execution identity and available credentials central architecture decisions.

OWASP’s guidance on excessive agency identifies excessive functionality, permissions, and autonomy as distinct sources of risk. It recommends minimizing access and enforcing authorization in downstream systems rather than relying on a model’s decision about what is allowed. [Source](https://genai.owasp.org/llmrisk/llm062025-excessive-agency/)

Apply those principles without assuming that every task needs the same restrictions.

A repository-search agent may need read access to one codebase. A test agent may need an isolated environment and access to a package source. A release workflow may need narrowly scoped deployment authority for a defined stage. Giving all three the same broad identity simplifies setup while making containment harder.

Keep development and production privileges distinct. Avoid automatically mounting unrelated credential files or forwarding credential agents into environments that do not need them. Give temporary workspaces a deliberate network policy and a defined cleanup process.

A container can help isolate a workload, but its mounts, host interfaces, network access, and credentials determine the protection it actually provides. The label “sandbox” is the start of a review, not its conclusion.

These are controls for the execution environment. A model instruction asking the agent to behave safely cannot enforce the same boundary against malicious software already running with the host’s permissions.

## What engineering leaders should change

### Make the engineering toolchain an owned system

Assign an accountable owner for the combined service, not just the editor subscription. Platform engineering, security, procurement, and engineering management each hold part of the picture.

| Area | Accountable function | Evidence to maintain |
| - | - | - |
| Approved tools and extensions | Platform engineering with security | Products, versions, publishers, distribution channels |
| Data use and suppliers | Procurement with security and privacy specialists | Feature-level flows, recipients, retention commitments |
| Developer identities | Identity and platform teams | Credential scopes, lifetimes, owners, revocation paths |
| Endpoint execution | Endpoint security | Installation records, process and network telemetry |
| Incident coordination | Security response with engineering leadership | Notification routes, exposure assessments, recovery decisions |

The exact organization chart can differ. The important requirement is that somebody can connect a supplier alert to affected users, packages, data, and credentials.

### Ask the vendor to describe the failure boundaries

A security review should establish more than a list of certifications or an assertion that data is encrypted.

Ask:

1. Which features send engineering content to which service providers, including diagnostic and evaluation workflows?

2. Which data stores are retained outside the live inference path, and how is access granted and expired?

3. What prevents a credential issued for one integration from reaching unrelated systems?

4. How are published packages validated when served through mirrors and caches?

5. Which identities can modify artifacts or distribution infrastructure, and how is their activity recorded?

6. Can affected customers receive specific exposure information and export relevant administrative evidence?

7. Can the organization disable a compromised feature or supplier route without losing unrelated capabilities?

Ask for the implementation and scope relevant to your plan. A control in one product tier or deployment model does not establish that it exists everywhere.

### Measure whether the controls work

Useful operating measures include the proportion of engineering endpoints with an extension inventory, the time required to locate an affected package, the time required to revoke a compromised integration identity, and the proportion of retained datasets with an owner and expiration policy.

Run a controlled exercise: a supplier reports that a historical dataset and a particular plugin release may be affected. Can the team identify relevant exposures without collecting secrets into a shared spreadsheet?

That exercise tests the connections between teams. A completed questionnaire cannot demonstrate the same capability.

## How to respond without confusing exposure types

An incident assessment should begin by identifying the applicable exposure, rather than assuming every user of a product is affected in the same way.

| Exposure question | Evidence to examine | Response objective |
| - | - | - |
| Was engineering content disclosed? | Vendor-specific affected-data information and retained-data records | Establish the content, recipients, and potential consequences |
| Were usable credentials disclosed? | Identified secrets, their validity, scope, and access logs | Revoke access and investigate possible subsequent use |
| Did malicious software execute? | Package identity, installation time, endpoint and network evidence | Contain and investigate the host, then restore a trusted state |

These categories can overlap. Their evidence and remediation should remain explicit.

### For this extension exposure, use the official notice

Cursor’s notice identifies **Anthropic.claude-code versions 2.1.312 and 2.1.313**, distributed through its VS Code Extension Marketplace for macOS and Windows during the specified **29 October window, approximately 2:27 a.m. to 1:35 p.m. Pacific Time**. The notice describes attempted persistent Secure Shell (SSH) access, while also documenting failures affecting parts of the malicious behavior. Potential package delivery should not be reported as proof that every affected host had successful remote access. [Source](https://cursor.com/blog/claude-code-extension-security-notice)

Its guidance calls for checking the published indicators, isolating hosts with relevant evidence, removing persistence, assessing whether rebuilding is necessary, and rotating accessible credentials and sessions from a trusted system. It warns that uninstalling the extension alone may not remove the persistence. Use the [current official notice and remediation resources](https://cursor.com/blog/claude-code-extension-security-notice) rather than copied commands in a general article.

### Coordinate containment with investigation

Have the incident-response team decide the appropriate sequence for containment and evidence collection. Avoid destroying relevant endpoint evidence through an ad hoc cleanup while allowing an active threat to continue unchecked.

Treat credential replacement as a verified process. Confirm the old access is revoked, the replacement works, dependent services remain healthy, and relevant logs have been reviewed. Restoring access is not the same as establishing that no additional access occurred.

Use established incident-response ownership and procedures. NIST’s current incident-response guidance, Special Publication 800-61 Revision 3, places detection, response, and recovery within broader cybersecurity risk management. [Source](https://csrc.nist.gov/pubs/sp/800/61/r3/final)

The useful deliverable is a scoped assessment: what is known, what remains unresolved, which containment actions were completed, and what evidence supports restoration.

## A practical 30-day plan

Separate urgent exposure assessment from the longer program of strengthening the engineering environment. Teams with confirmed compromise should follow their incident process immediately rather than treating the schedule below as a response deadline.

**Days 1–3: Establish visibility.** Identify owners for AI coding products, installed extensions, connected services, and supplier notifications. Reconcile corporate subscriptions with endpoint observations. Check relevant incident notices and record the scope of any exposure assessment.

**Days 4–10: Map sensitive flows and identities.** Trace representative coding, debugging, support, and evaluation workflows. Identify retained content, subprocessors, credentials, expiration rules, and privileged developer access. Prioritize the paths with the greatest potential consequence.

**Days 11–20: Close the most consequential gaps.** Remove unused integrations, narrow excessive access, strengthen extension installation controls, and limit unnecessary credential exposure in agent environments. Test representative secret scanning and document the limits it cannot address.

**Days 21–30: Exercise the response.** Simulate a vendor-data exposure and a compromised extension release. Measure how quickly teams can identify potentially affected endpoints and identities, stop the relevant access, and produce a defensible recovery decision.

Do not judge progress solely by policy publication. The practical question is whether the organization can answer a specific supplier alert with specific evidence.

## What this changes in the market

The likely market shift is toward treating AI developer tools as an engineering platform dependency, with corresponding expectations for supplier transparency and operational control.

For **AI coding vendors**, model quality and workflow speed will remain important. Enterprise buyers will also ask for precise data-use boundaries, inspectable distribution controls, scoped integrations, and useful incident notifications. Supplier relationships that were previously implementation details become part of the purchasing discussion.

For **platform engineering teams**, an approved development environment can become more valuable. A maintained set of tools, identities, extension sources, and execution policies reduces the burden on individual developers to evaluate every trust relationship themselves.

For **security teams**, the review needs to connect information exposure with execution authority. A data-loss assessment and an endpoint assessment may begin separately, but they should share an understanding of the identities and systems linking them.

For **developers**, the outcome should be a usable, supported route to the capabilities they need. Controls that are impossible to work within encourage unmanaged alternatives. Provide approved tools, clear exceptions, and a responsive process for adding useful capabilities.

My expectation is that vendors able to explain and demonstrate these boundaries will have an advantage in enterprise adoption. The stronger purchasing question will be what happens when one component fails and how far that failure can travel.

## Frequently asked questions

### Is an AI coding tool really part of the software supply chain?

Yes. It can influence the code, commands, packages, and configuration involved in development. Depending on the product, it can also receive engineering information or execute software inside the development environment. Those relationships belong in the supply-chain review.

### Does disabling training protect every data path?

A training restriction addresses a particular use of data. Review retention, diagnostics, support, analytics, and service providers separately. The product’s exact commitments and configuration determine which controls apply.

### Does Privacy Mode prevent malicious extensions?

A privacy setting and an extension-integrity control serve different purposes. Check the vendor’s statement for the data exposure in question, then independently assess any relevant package-installation or endpoint exposure. Do not infer protection across unrelated boundaries.

### Is an extension allowlist enough?

An allowlist helps control which extensions can be installed. Additional questions include package integrity, publisher identity, delivery-channel security, update behavior, and the privileges available at runtime.

### Should we stop using AI coding tools?

Make the decision according to the tool, workload, access, and available controls. A targeted restriction may be appropriate during an incident. Longer-term decisions should compare demonstrable protections and business value rather than treating all tools or all configurations as equivalent.

## The engineering boundary to redraw

The code repository is an important security boundary, but it is only one part of the environment in which software is now produced.

AI-assisted engineering connects context collection, model services, traces, support systems, extensions, developer identities, and execution environments. Each connection creates a question about who can observe information or exercise authority.

The leadership task is to make those questions explicit and put effective controls at the relevant boundaries. Inventory the tools. Map the data. Constrain credentials. Verify delivery. Prepare to investigate the connections.

**If a tool can observe engineering work or act inside the development environment, include it in the supply chain you govern.**

## Sources and further reading

- [Cursor investigation update, 13 November 2026](https://cursor.com/blog/security-incident-update)

- [Cursor extension security notice and current remediation](https://cursor.com/blog/claude-code-extension-security-notice)

- [Fireworks security bulletin, updated 9 November 2026](https://fireworks.ai/security/bulletins/october-2026-security-incident-update)

- [Notion advisory concerning Fireworks, including 13 November update](https://www.notion.com/en-gb/security/advisories/security-incident-involving-a-third-party-ai-vendor)

- [Visual Studio Code extension runtime security](https://code.visualstudio.com/docs/configure/extensions/extension-runtime-security)

- [OWASP Secrets Management Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Secrets_Management_Cheat_Sheet.html)

- [OWASP guidance on excessive agency](https://genai.owasp.org/llmrisk/llm062025-excessive-agency/)

- [NIST incident-response guidance](https://csrc.nist.gov/pubs/sp/800/61/r3/final)

## Related reading

- [Agent Reliability Engineering: SRE for AI](/blog/agent-reliability-engineering-sre-for-ai/)

- [Multi-Agent Orchestration Patterns: The Architecture Reference You're Missing](/blog/multi-agent-orchestration-patterns/)

- [Beyond RAG: The Rise of Context Engineering](/blog/beyond-rag-context-engineering/)

- [AI Agents Are Automating Penetration Testing. Can Your Security Team Keep Up?](/blog/ai-penetration-testing-agents/)

- [Self-Hosted AI Agents: What You Actually Control When You Bring Them In-House](/blog/self-hosted-ai-agents/)
