Documentation

Topics Overview Overview Linux macOS Windows VS Code for the Web Raspberry Pi Network Additional Components Uninstall VS Code Tutorial Copilot Quickstart User Interface Personalize VS Code Install Extensions Tips and Tricks Intro Videos Overview Setup Quickstart Overview Language Models Context Tools Agents Customization Trust & Safety Overview Agents Tutorial Agents Window Planning Memory Tools Subagents Local Agents Copilot CLI Cloud Agents Third-Party Agents Overview Chat Sessions Add Context Inline Chat Review Edits Checkpoints Artifacts Panel Debug Chat Interactions Prompt Examples Overview Instructions Prompt Files Custom Agents Agent Skills Language Models MCP Hooks Plugins Context Engineering Customize AI Test-Driven Development Edit Notebooks with AI Test with AI Test Web Apps with Browser Tools Debug with AI MCP Dev Guide OpenTelemetry Monitoring Inline Suggestions Smart Actions Best Practices Security Troubleshooting FAQ Cheat Sheet Settings Reference MCP Configuration Workspace Context Display Language Layout Keyboard Shortcuts Settings Settings Sync Extension Marketplace Extension Runtime Security Themes Profiles Overview Voice Interactions Command Line Interface Telemetry Basic Editing IntelliSense Code Navigation Refactoring Snippets Overview Multi-Root Workspaces Workspace Trust Tasks Debugging Debug Configuration Testing Port Forwarding Integrated Browser Overview Quickstart Staging & Committing Branches & Worktrees Repositories & Remotes Merge Conflicts Collaborate on GitHub Troubleshooting FAQ Getting Started Tutorial Terminal Basics Terminal Profiles Shell Integration Appearance Advanced Overview Enterprise Policies AI Settings Extensions Telemetry Updates Overview JavaScript JSON HTML Emmet CSS, SCSS and Less TypeScript Markdown PowerShell C++ Java PHP Python Julia R Ruby Rust Go T-SQL C# .NET Swift Working with JavaScript Node.js Tutorial Node.js Debugging Deploy Node.js Apps Browser Debugging Angular Tutorial React Tutorial Vue Tutorial Debugging Recipes Performance Profiling Extensions Tutorial Transpiling Editing Refactoring Debugging Quick Start Tutorial Run Python Code Editing Linting Formatting Debugging Environments Testing Python Interactive Django Tutorial FastAPI Tutorial Flask Tutorial Create Containers Deploy Python Apps Python in the Web Settings Reference Getting Started Navigate and Edit Refactoring Formatting and Linting Project Management Build Tools Run and Debug Testing Spring Boot Modernizing Java Apps Application Servers Deploy Java Apps GUI Applications Extensions FAQ Intro Videos GCC on Linux GCC on Windows GCC on Windows Subsystem for Linux Clang on macOS Microsoft C++ on Windows Build with CMake CMake Tools on Linux CMake Quick Start C++ Dev Tools for Copilot Editing and Navigating Debugging Configure Debugging Refactoring Settings Reference Configure IntelliSense Configure IntelliSense for Cross-Compiling FAQ Intro Videos Get Started Navigate and Edit IntelliCode Refactoring Formatting and Linting Project Management Build Tools Package Management Run and Debug Testing FAQ Overview Node.js Python ASP.NET Core Debug Docker Compose Registries Deploy to Azure Choose a Dev Environment Customize Develop with Kubernetes Tips and Tricks Overview Jupyter Notebooks Data Science Tutorial Python Interactive Data Wrangler Quick Start Data Wrangler PyTorch Support Azure Machine Learning Manage Jupyter Kernels Jupyter Notebooks on the Web Data Science in Microsoft Fabric Foundry Toolkit Overview Foundry Toolkit Copilot Tools Create Agents Models Playground Agent Builder Agent Inspector Evaluation Tool Catalog Fine-Tuning (Automated Setup) Fine-Tuning (Project Template) Model Conversion Tracing Profiling (Windows ML) FAQ File Structure Manual Model Conversion Manual Model Conversion on GPU Setup Environment Without Foundry Toolkit Template Project Migrating from Visualizer to Agent Inspector Overview Getting Started Resources View Deployment VS Code for the Web - Azure Containers Azure Kubernetes Service Kubernetes MongoDB Remote Debugging for Node.js Overview SSH Dev Containers Windows Subsystem for Linux GitHub Codespaces VS Code Server Tunnels SSH Tutorial WSL Tutorial Tips and Tricks FAQ Overview Tutorial Attach to Container Create Dev Container Advanced Containers devcontainer.json Dev Container CLI Tips and Tricks FAQ Default Keyboard Shortcuts Default Settings Substitution Variables Tasks Schema

On this page there are 13 sections

Agent plugins in VS Code (Preview)

Agent plugins are prepackaged bundles of agent customizations that you can discover and install from plugin marketplaces in Visual Studio Code. A single plugin can provide any combination of slash commands, agent skills, custom agents, hooks, and MCP servers.

Plugins work alongside your locally defined customizations. When you install a plugin, its commands, skills, agents, hooks, and MCP servers appear in chat.

Note

Agent plugins are currently in preview. Enable or disable support for agent plugins with the chat.plugins.enabled Open in VS Code Open in VS Code Insiders This setting is managed at the organization level. Contact your administrator to change it. setting.

What plugins provide

An agent plugin can bundle one or more of the following customization types:

Slash commands: additional commands you can invoke with / in chat
Skills: agent skills with instructions, scripts, and resources that load on-demand
Agents: custom agents with specialized personas and tool configurations
Hooks: hooks that execute shell commands at agent lifecycle points
MCP servers: MCP servers for external tool integrations

For example, a testing plugin might include a test-runner skill with scripts, a test-reviewer agent with read-only tools, and an MCP server for a test reporting dashboard. The plugin directory structure looks like this:

{ "name": "my-dev-tools", "description": "React development utilities", "version": "1.2.0", "author": { "name": "Jane Doe" }, "skills": "skills/", "agents": "agents/", "hooks": "hooks.json", "mcpServers": ".mcp.json" }

Plugin formats

VS Code auto-detects the plugin format by checking for format-specific manifest paths. Copilot format is used as the default when no other format markers are found.

Plugin format Plugin file path(s)

Claude	.claude-plugin/plugin.json
OpenPlugin	.plugin/plugin.json

Plugin environment variables

Some plugin formats provide a root token that you can use in hook commands and MCP server configurations to reference files within the plugin directory. VS Code expands the token at runtime and also sets it as an environment variable in the hook or server process.

Plugin format Plugin root

Claude	${CLAUDE_PLUGIN_ROOT}
Copilot	(Not defined)
OpenPlugin	${PLUGIN_ROOT}

Hooks in plugins

Plugins can include hooks that run shell commands at agent lifecycle points. Plugin hooks work alongside your workspace and user-level hooks. When a plugin is enabled, its hooks fire in addition to any other hooks configured for the same event.

Hook file location

The hook file location depends on the plugin format:

Plugin format Hook file path

Claude	hooks/hooks.json
Copilot	hooks.json (at the plugin root)

VS Code auto-detects the plugin format and discovers the hook file automatically.

{ "hooks": { "PostToolUse": [ { "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/scripts/format.sh" } ] } }

Matcher format (Claude compatibility syntax):

{ "hooks": { "PreToolUse": [ { "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/scripts/validate-tool.sh" } ] } }

Supported hook events

Plugin hooks support the same lifecycle events as workspace hooks: SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, PreCompact, SubagentStart, SubagentStop, and Stop. See Hook lifecycle events for details on each event.

How plugin hooks interact with other hooks

Plugin hooks run alongside workspace-level and user-level hooks. When multiple hooks target the same event, all of them execute. For PreToolUse hooks, the most restrictive permission decision across all hooks wins: deny overrides ask, which overrides allow.

Disabling a plugin also disables its hooks. You can enable or disable plugins globally or for a specific workspace from the Extensions view.

MCP servers in plugins

Plugins can bundle MCP servers to provide agents with additional tools and data sources. Plugin MCP servers start automatically when the plugin is enabled and stop when the plugin is disabled.

MCP configuration file

Place MCP server definitions in .mcp.json at the plugin root. VS Code discovers this file automatically when it loads the plugin.

{ "mcpServers": { "plugin-database": { "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server", "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"], "env": { "DB_PATH": "${CLAUDE_PLUGIN_ROOT}/data" } }, "plugin-api": { "command": "npx", "args": ["@company/mcp-server", "--plugin-mode"], "cwd": "${CLAUDE_PLUGIN_ROOT}" } } }

Note

The top-level key is mcpServers (not servers as in the workspace mcp.json).

Reference plugin paths in server configuration

For Claude-format plugins, use the ${CLAUDE_PLUGIN_ROOT} token in MCP server fields to reference executables and files within the plugin directory. VS Code expands this token in the following fields:

command: the executable path
args: command-line arguments
cwd: working directory
env: environment variable values
envFile: path to an environment file
url: for HTTP-based MCP servers
headers: HTTP header values

VS Code also injects a CLAUDE_PLUGIN_ROOT environment variable into the server process, so server code can access the plugin path at runtime.

How plugin MCP servers interact with other servers

Plugin MCP servers appear alongside workspace and user-level MCP servers. You can manage them through the same tools:

Select Configure Tools in the Chat view to see tools from all MCP servers, including plugin servers.
Run MCP: List Servers from the Command Palette to view plugin servers alongside other servers.

Plugin MCP servers are implicitly trusted when you install the plugin. Unlike workspace MCP servers, they do not show a separate trust prompt at startup.

Disabling a plugin stops its MCP servers. Tools provided by the stopped servers are no longer available in chat.

Discover and install plugins

VS Code provides a dedicated view in the Extensions sidebar to browse and manage agent plugins.

Browse available plugins

Open the Extensions view (⇧⌘X (Windows, Linux Ctrl+Shift+X)) and enter @agentPlugins in the search field.

Alternatively, select the More Actions (three dots) icon in the Extensions sidebar and choose Views > Agent Plugins.
Browse the list of available plugins from your configured marketplaces.
Select Install to install a plugin in your user profile.

The first time you install a plugin from a new marketplace, VS Code shows a trust prompt. Review the marketplace source before confirming.

Install a plugin from source

You can install a plugin directly from a Git repository URL, without adding a full marketplace first.

Run Chat: Install Plugin From Source from the Command Palette.
Alternatively, select the + button on the Plugins page of the Agent Customizations editor.

Enter a Git repository URL (for example, https://github.com/rwoll/markdown-review) and VS Code clones and installs the plugin.

Plugins installed by GitHub Copilot CLI

VS Code automatically discovers plugins that you install with the GitHub Copilot CLI to enable you to use them also in VS Code. Plugins from ~/.copilot/installed-plugins/ appear in the Agent Plugins - Installed view alongside plugins you installed from a marketplace or from source.

The CLI stores plugins under ~/.copilot/installed-plugins/<marketplace>/<plugin>/. Plugins installed directly from a Git URL (rather than from a marketplace) live under the _direct bucket, for example ~/.copilot/installed-plugins/_direct/github--moda-linter--copilot-plugin/.

View installed plugins

The Agent Plugins - Installed view in the Extensions view shows the plugins you have installed. From this view, you can enable, disable, or uninstall plugins.

You can also manage installed plugins from the Chat view by selecting the gear icon > Plugins.

Enable or disable plugins

You can enable or disable a plugin globally or for a specific workspace:

Use the context menu on a plugin in the Agent Plugins - Installed section of the Extensions view.
Use the Agent Customizations editor to toggle a plugin's enabled state.

The enable/disable state is stored separately from the plugin configuration, so it does not affect shared workspace settings.

When a plugin is disabled, its skills, agents, hooks, MCP servers, and slash commands are no longer available. For example, skills from a disabled plugin do not appear in Chat: Configure Skills. Disabled plugins appear with a dimmed style in the Agent Customizations editor and Extensions view.

Uninstall plugins

To remove a plugin, right-click it in the Agent Plugins - Installed view and select Uninstall. Plugins installed from an external source (such as npm, PyPI, or an external Git repository) are removed from disk. Plugins that are inlined in a marketplace repository remain on disk but are no longer active.

Configure plugin marketplaces

By default, VS Code discovers plugins from the copilot-plugins and awesome-copilot. You can add additional marketplaces with the chat.plugins.marketplaces Open in VS Code Open in VS Code Insiders setting.

Marketplaces are Git repositories that contain plugin definitions. You can reference them in several formats:

Shorthand: owner/repo for public GitHub repositories. For example, anthropics/claude-code.
HTTPS git remote: a full URL ending in .git. For example, https://github.com/anthropics/claude-code.git.
SCP-style git remote: SSH-style references. For example, git@github.com:anthropics/claude-code.git.
file URI: a file:/// path to a marketplace repository already cloned on disk.

Private repositories are also supported. If a public lookup fails, VS Code falls back to cloning the repository directly.

Marketplace plugins can also reference external package sources such as npm or PyPI packages. For the full marketplace plugin schema, see the Claude Code plugin marketplace documentation.

// settings.json "chat.pluginLocations": { "/path/to/my-plugin": true, "/path/to/another-plugin": false }

Set the value to true to enable the plugin, or false to keep it registered but disabled.

Update plugins

VS Code checks for plugin updates when you run Extensions: Check for Extension Updates from the Command Palette, or automatically every 24 hours when extensions.autoUpdate Open in VS Code Open in VS Code Insiders is enabled.

Updating pulls down changes from cloned marketplace repositories and checks for new versions of externally sourced plugins.

Plugins sourced from npm or PyPI never update automatically. Instead, they show an Update button in the Extensions view. Selecting the button prompts you to confirm before running the install command. If an update is found during a background check, no action is taken until you explicitly select Update.

Workspace plugin recommendations

Projects can recommend plugins for team members by configuring plugin settings in the workspace settings (.claude/settings.json or .github/copilot/settings.json).

VS Code shows a notification the first time a chat message is sent. You can view the recommended plugins by opening the Extensions view and filtering by @agentPlugins @recommended.

Specify the following fields in the settings file to configure workspace plugin recommendations:

extraKnownMarketplaces: registers additional marketplaces for the project. These marketplaces appear when you search @agentPlugins in the Extensions view.
enabledPlugins: lists plugins that should be enabled by default.