Agent plugins are prepackaged bundles of agent customizations that you can discover and install from plugin marketplaces in Visual Studio Code. Plugins work alongside your locally defined customizations. When you install a plugin, its supported customizations appear in chat.

Agent Plugins is an open standard for packaging agent skills and MCP servers that works across multiple AI agents, including GitHub Copilot in VS Code, GitHub Copilot CLI, and the GitHub Copilot app. Through its existing Copilot and Claude plugin formats, VS Code also supports client-specific plugin capabilities, including slash commands, custom agents, and hooks.

For how plugins fit into the broader set of customization options, see Customization concepts.

Note

Enable or disable support for agent plugins with the chat.plugins.enabled setting.

What plugins provide

Agent Plugins 1.0 defines skills and MCP servers as portable component types. Other capabilities are client-specific and can use the standard's reverse-domain client extension namespaces. VS Code currently ignores client extension data and directories in Agent Plugins 1.0 packages.

Capability	Description	Client-specific	Standard
MCP servers	External tool integrations		✓
Skills	Instructions, scripts, and resources that load on-demand		✓
Agents	Specialized personas and tool configurations	✓
Hooks	Shell commands that execute at agent lifecycle points	✓
Slash commands	Commands you can invoke with `/` in chat	✓

For example, a Copilot-format 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:

{
  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
  "name": "my-dev-tools",
  "description": "React development utilities",
  "version": "1.2.0"
}

Field	Type	Required	Description
`$schema`	string	Yes	Canonical Agent Plugins schema identifier.
`name`	string	Yes	Plugin name and package identifier.
`version`	string	No	Plugin version. Semantic Versioning is recommended.
`description`	string	No	Brief description of the plugin.
`author`	object	No	Author information with optional `name`, `email`, and `url` fields.
`homepage`	string	No	Documentation or homepage.
`repository`	string	No	Source repository.
`license`	string	No	License identifier. An SPDX identifier is recommended.
`keywords`	string[]	No	Search and discovery terms.
`extensions`	object	No	Client-specific data keyed by reverse-domain namespace.

Skills are discovered from the skills/ folder, and MCP server configuration is discovered from the mcp.json file. You don't list these component paths in the manifest. Custom agents, hooks, commands, and MCP server definitions are not portable top-level manifest fields.

For the full field constraints and validation rules, see the Agent Plugins manifest documentation.

Plugin formats

VS Code auto-detects the plugin format by checking the root manifest and format-specific manifest paths. A root plugin.json that declares the canonical Agent Plugins $schema uses Agent Plugins semantics. The Copilot format is used as the default when no other format marker is found.

Plugin format	Plugin manifest
Agent Plugins 1.0	`plugin.json` with `$schema` set to `https://agent-plugins.org/schemas/1.0.0/plugin.schema.json`
Copilot	`plugin.json`
Claude	`.claude-plugin/plugin.json`
Legacy 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
Agent Plugins 1.0	`${PLUGIN_ROOT}`
Claude	`${CLAUDE_PLUGIN_ROOT}`
Copilot	`${PLUGIN_ROOT}` or `${CLAUDE_PLUGIN_ROOT}`
Legacy OpenPlugin	`${PLUGIN_ROOT}`

Agent Plugins 1.0 also defines ${PLUGIN_ROOT} for packaged files and ${PLUGIN_DATA} for writable state that persists across plugin updates. VS Code preserves these placeholders for the plugin runtime to expand. For details about where placeholders are supported, see the Agent Plugins specification.

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 the mcp.json file at the plugin root and follow the portable MCP configuration format.

my-plugin/
  hooks/
    hooks.json           # Hook configuration (Claude format)
  scripts/
    format.sh            # Hook script referenced by hooks.json

Hook configuration format

Plugin hooks use the same base format as workspace hooks. VS Code parses Claude Code hook configuration, including matcher syntax. Currently, VS Code ignores matcher values, so hooks run on every matching event.

Flat format (same as workspace hooks):

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

VS Code parses the matcher field for compatibility with Claude Code, but currently ignores matcher values. If you need to filter hook behavior in VS Code, check the event input inside the hook script.

Reference plugin paths in hook commands

For Claude-format plugins, use the ${CLAUDE_PLUGIN_ROOT} token in hook commands to reference scripts and files within the plugin directory. VS Code expands this token to the plugin's absolute path at runtime and also sets a CLAUDE_PLUGIN_ROOT environment variable for the hook process. Inside your script, access this as $CLAUDE_PLUGIN_ROOT (or %CLAUDE_PLUGIN_ROOT% on Windows).

This is important because plugins are installed to a location outside your workspace, so you cannot use relative paths.

// settings.json
"chat.plugins.marketplaces": [
    "anthropics/claude-code"
]

Use local plugins

If you manually clone or download a plugin, you can register it with the chat.pluginLocations setting. This setting maps local plugin directory paths to an enabled or disabled state. Set the value to true to enable the plugin, or false to keep it registered but disabled.

{
  "extraKnownMarketplaces": {
    "company-tools": {
      "source": {
        "source": "github",
        "repo": "your-org/plugin-marketplace"
      }
    }
  },
  "enabledPlugins": {
    "code-formatter@company-tools": true
  }
}

Cross-tool compatibility

Agent Plugins 1.0 is an open standard designed for cross-tool compatibility. A conformant plugin uses a root plugin.json, puts skills in skills/, and puts MCP server configuration in mcp.json. Compatible clients can discover the portable component types they support from the same package.

Agent Plugins can also include client-specific manifest data and files under a stable reverse-domain namespace. Clients ignore namespaces they don't implement, so client-specific capabilities don't prevent other clients from loading the portable components. VS Code currently ignores these namespaces and loads only the portable skills and MCP server configuration.

For example:

">GitHub Copilot CLI plugin reference

8/12/2026