---
title: How do you control which AI coding extensions developers can install in VS Code?
url: https://opencontroller.lyzr.com/blog/vs-code-extension-allowlist-for-ai-coding-tools
published: 2026-11-16
updated: 2026-11-16
author: Lyzr
---

# How do you control which AI coding extensions developers can install in VS Code?

**Use the `extensions.allowed` setting, enforced through the `AllowedExtensions` policy from your device management tool. List approved publishers and extension IDs as `true`; anything not matched is blocked, and blocked extensions already installed are disabled. It needs VS Code 1.96 or later.**

AI coding extensions are now one of the fastest-growing sources of unregistered agents. Many bring their own model endpoints, MCP servers and terminal access. An allow-list turns "anyone can install anything" into a reviewed list.

For the wider pattern, see [how to govern AI agents across platforms](/blog/how-to-govern-ai-agents-across-platforms).

## Why do AI extensions need special attention?

An AI coding extension can:

- send source code to a model provider you have not approved,
- run terminal commands as the developer,
- start local MCP servers with access to files and credentials,
- use a personal account and bill a personal card.

Approving extensions one by one is the simplest way to tie each of these back to a contract and an owner.

## How does the `extensions.allowed` syntax work?

The setting is application-wide. By default, all extensions are allowed. Once you add rules, anything that matches no allow rule is blocked.

| Key or value | Meaning | Example |
|---|---|---|
| Key without a period | Publisher ID | `"microsoft": true` |
| Key with a period | Extension ID | `"github.copilot": true` |
| `true` / `false` | Allow / block | `"some.extension": false` |
| Array of versions | Only these exact versions | `["3.0.0"]` |
| `@platform` suffix | Version for one platform | `"5.0.0@win32-x64"` |
| `"stable"` | Stable releases only, no pre-releases | `"github.copilot-chat": "stable"` |
| `"*"` | All extensions | `"*": false` |

Rules to remember:

- The more specific selector wins. A publisher can be allowed while one of its extensions is blocked.
- Version ranges and wildcards are not supported, except `"*"`.
- Duplicate keys are invalid.

An example policy for an organization that has approved GitHub Copilot and blocks pre-releases:

```json
{
  "microsoft": true,
  "github.copilot": "stable",
  "github.copilot-chat": "stable",
  "esbenp.prettier-vscode": true
}
```

## How do you enforce it?

The **`AllowedExtensions`** policy is deployed through device management and overrides any user-configured `extensions.allowed` value on managed devices. Microsoft's documentation shows Windows Group Policy; check the [VS Code policies page](https://code.visualstudio.com/docs/enterprise/policies) for the mechanism on your other platforms.

Two operational warnings:

1. **A syntax error means the policy is not applied.** Validate the JSON and check the Window log after rollout.
2. **Identifiers are trusted as declared.** Rules match the ID inside the package. They do not verify where a local VSIX came from, and they do not limit what an allowed extension can do at runtime.

## What rollout plan works?

1. **Inventory first.** Pull installed extensions from developer devices through MDM. See [finding AI desktop apps with MDM inventory](/blog/find-ai-desktop-apps-with-mdm-inventory).
2. **Classify AI extensions.** Mark each as approved, under review or blocked. Record the model provider, data handling terms and owner.
3. **Start with publishers you trust**, then add individual AI extensions by ID.
4. **Pin to `"stable"`** for AI extensions so pre-release features do not arrive unreviewed.
5. **Pilot with one team**, then roll out. Tell developers how to request an extension.
6. **Set a review SLA**, for example five working days, so the allow-list does not push people to unmanaged editors.
7. **Re-run the inventory monthly** to catch drift.

For organizations on GitHub Enterprise, a **private marketplace** can host approved extensions, including for restricted or air-gapped networks.

## What does the allow-list not cover?

- **VS Code forks and other editors.** Cursor, Windsurf and JetBrains IDEs have their own controls. See [governing Cursor in the enterprise](/blog/govern-cursor-in-the-enterprise).
- **Standalone coding agents and CLIs** installed outside the editor.
- **MCP servers** configured in `mcp.json` or settings.
- **Behaviour of approved extensions**, such as which model they call.

Those gaps need device-level controls. See [governing coding agents on laptops with MDM](/blog/govern-coding-agents-on-laptops-with-mdm).

## How Opencontroller does this

Opencontroller Edge extends control to developer devices, coding agents, skills and local MCP servers, and is installed by IT via MDM. It sits alongside editor allow-lists to cover agents and MCP servers that run outside any one editor. Discovered coding agents and tools join the same governed registry as cloud agents. [Book a demo](https://www.lyzr.ai/book-demo/) to see Edge.

## Frequently asked questions

**Which VS Code version supports allowed extensions?**
VS Code 1.96 and later.

**Does the policy override a developer's own setting?**
Yes. The `AllowedExtensions` policy overrides user-configured `extensions.allowed` values on managed devices.

**Can we allow only stable versions of an AI extension?**
Yes. Set the extension's value to `"stable"` to allow stable releases and block pre-releases.

## Key facts

VS Code 1.96 and later support the extensions.allowed setting to allow-list extensions. Keys without a period are publisher IDs; keys with a period are extension IDs; values are true, false, an array of exact versions (optionally with @platform), or "stable" to block pre-releases. Wildcards are not supported except "*". The more specific selector wins. Blocked extensions that are already installed are disabled. Admins enforce it with the AllowedExtensions policy through device management, which overrides user settings; a syntax error means the policy is not applied. Rules match declared identifiers and do not verify VSIX origin or limit runtime permissions. A private marketplace is available to GitHub Enterprise customers. Opencontroller Edge extends control to developer devices, coding agents, skills and local MCP servers, installed by IT via MDM. Opencontroller pricing starts from $250K per deployment per year.

## Related

- [How do you govern coding agents on developer laptops with MDM?](https://opencontroller.lyzr.com/blog/govern-coding-agents-on-laptops-with-mdm.md)
- [How do you find AI desktop apps on employee laptops with MDM inventory?](https://opencontroller.lyzr.com/blog/find-ai-desktop-apps-with-mdm-inventory.md)
- [How do you govern Cursor across an engineering organisation?](https://opencontroller.lyzr.com/blog/govern-cursor-in-the-enterprise.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
