Codestin Search App

Plugins provide a way to distribute custom Copilot functionality. You can use a plugin to add a preconfigured set of capabilities to Copilot, including Copilot CLI, Copilot cloud agent, and the GitHub Copilot app.

What is a plugin?

A distributable package that extends Copilot's functionality.
A bundle of components in a single installable unit.

What plugins contain

A plugin can contain some or all of the following components. The locations of these components depend on the plugin format:

Custom agents — Specialized AI assistants (*.agent.md files in agents/)
Skills — Discrete callable capabilities (skills subdirectories in skills/, containing a SKILL.md file)
Hooks — Event handlers that intercept agent behavior (a hooks.json file in the plugin root, or in hooks/)
MCP server configurations — Model Context Protocol integrations
LSP server configurations — Language Server Protocol integrations (an lsp.json file in the plugin root, or in .github/)

Plugin formats

Copilot supports two plugin formats:

Agent Plugins 1.0 is a portable format for sharing skills and MCP server configurations across compatible clients. To use this format, set $schema in plugin.json to https://agent-plugins.org/schemas/1.0.0/plugin.schema.json. Skills are discovered from skills/, and MCP server configuration is discovered from mcp.json at the plugin root. These locations cannot be configured in the manifest. Choose Agent Plugins 1.0 when you want to make skills and MCP servers portable.
Legacy Copilot plugins do not declare the Agent Plugins $schema. They use the existing manifest fields and component discovery behavior, including configurable component paths and MCP configuration in .mcp.json, .github/mcp.json, or the mcpServers manifest field. Choose the legacy format when you need configurable component paths or are maintaining an existing Copilot-specific plugin.

For a new plugin, use Agent Plugins 1.0 unless you require configurable component paths. Use the legacy format primarily for existing legacy plugins.

Both formats are supported. Adding $schema changes how Copilot interprets the manifest and discovers components. Plugins without $schema continue to load as legacy plugins.

How plugins are structured

A plugin is a directory with a specific structure and a plugin.json manifest file. Agent Plugins 1.0 requires the manifest at the plugin root. Legacy plugins support additional manifest locations. The manifest gives the plugin a name and metadata. Depending on the format, it can also point to components. Alongside the manifest, the directory can contain agents, skills, hooks, MCP server configurations, and LSP server configurations.

Agent Plugins 1.0 structure

Agent Plugins 1.0 stores skills and MCP servers in standard locations so compatible clients can discover them. Other components, including agents, hooks, commands, and LSP servers, are client-specific. Copilot reads these components from the com.github.copilot directory. Other clients ignore this directory, so the same plugin can combine shared skills and MCP servers with Copilot-specific components.

An Agent Plugins 1.0 directory can look like this:

my-plugin/
├── plugin.json               # Required manifest
├── skills/                   # Skills (optional)
│   └── deploy/
│       └── SKILL.md
├── mcp.json                  # MCP server config (optional)
└── com.github.copilot/       # Copilot components (optional)
    ├── agents/
    │   └── helper.agent.md
    ├── commands/
    ├── rules/
    ├── hooks/
    │   └── hooks.json
    └── lsp.json

The manifest must include the Agent Plugins 1.0 $schema. For supported top-level manifest fields, name requirements, and component locations, see Agent Plugins 1.0 manifest fields.

Legacy plugin structure

A legacy Copilot plugin directory can look like this:

my-plugin/
├── plugin.json           # Required manifest
├── agents/               # Custom agents (optional)
│   └── helper.agent.md
├── skills/               # Skills (optional)
│   └── deploy/
│       └── SKILL.md
├── hooks.json            # Hook configuration (optional)
├── .mcp.json             # MCP server config (optional)
└── lsp.json              # LSP server config (optional)

For the full set of fields you can include in the manifest, see GitHub Copilot CLI plugin reference. For step-by-step guidance on authoring a plugin, see Creating a plugin for GitHub Copilot CLI.

Why use plugins?

Plugins provide the following benefits:

Reusability across projects
Team standardization of Copilot configuration
Share domain expertise (for example, by providing the skills of a Rails expert, or a Kubernetes expert)
Encapsulate complex MCP server setups

Where can I get plugins?

You can install plugins from:

A marketplace
A repository
A local path

A marketplace is a location where developers can publish, discover, install, and manage plugins. It's a bit like an app store—but for plugins.

Examples of marketplaces include:

How you install a plugin depends on which client you're using:

In Copilot CLI, you can install plugins imperatively using the copilot plugin install command or the /plugin install slash command, or declaratively by adding the plugin to the enabledPlugins field of either a user-level ~/.copilot/settings.json file or a repository-level .github/copilot/settings.json file. See Finding and installing plugins for GitHub Copilot CLI.
In Copilot cloud agent, you install plugins declaratively by adding them to the enabledPlugins field of the repository's .github/copilot/settings.json file. To install plugins from a marketplace that isn't registered by default, you can also add the marketplace to the extraKnownMarketplaces field in the same file.
In the GitHub Copilot app, click Customize, then click Plugins to browse marketplaces and install plugins.

Enterprise administrators can define plugin standards that apply to users on the enterprise's Copilot plan, including specifying additional marketplaces and plugins that are automatically installed. See About enterprise-managed plugin standards.

How plugin marketplaces work

A plugin marketplace is a registry of plugins that you can browse and install from. A marketplace can be hosted in a repository on GitHub.com, in any other online Git hosting service, or on your local or shared file system.

A marketplace is defined by a marketplace.json file, which provides metadata about the marketplace and lists the plugins it makes available. Each entry in the marketplace's plugins array describes a plugin—including its name, description, version, and the path to the plugin's directory.

Because plugins in a marketplace are versioned, marketplaces make it easy to discover, install, and update plugins, and to share them across a team. For step-by-step guidance on creating a marketplace, see Creating a plugin marketplace for GitHub Copilot CLI.

Plugins compared with manual configuration

Any functionality that you could add with a plugin, you could also add by configuring Copilot manually—for example, by adding custom agent profiles or MCP servers. However, plugins provide several advantages over manual configuration:

Feature	Manual configuration in a repository	Plugin
Scope	Single repository	Any project
Sharing	Manual copy/paste	Install command or `enabledPlugins` entry
Versioning	Git history	Marketplace versions
Discovery	Searching repositories	Marketplace browsing

About GitHub Copilot plugins

Who can use this feature?

In this article