---
title: 'Installing and Using Plugins'
description: 'Learn how to find, install, and manage plugins that extend GitHub Copilot CLI with reusable agents, skills, hooks, and integrations.'
authors:
  - GitHub Copilot Learning Hub Team
lastUpdated: 2026-04-27
estimatedReadingTime: '8 minutes'
tags:
  - plugins
  - copilot-cli
  - fundamentals
relatedArticles:
  - ./building-custom-agents.md
  - ./creating-effective-skills.md
  - ./automating-with-hooks.md
prerequisites:
  - GitHub Copilot CLI installed
  - Basic understanding of agents, skills, and hooks
---

Plugins are installable packages that extend GitHub Copilot CLI with reusable agents, skills, hooks, and servers, all bundled into a single unit you can install with one command. Instead of manually copying agent files and configuring MCP servers across every project, plugins let you install a curated set of capabilities and share them with your team.

This article explains what plugins contain, how to find and install them, and how to manage your plugin library.

## What's Inside a Plugin?

A plugin bundles one or more of the following components:

| Component | What It Does | File Location |
|-----------|-------------|---------------|
| **Custom Agents** | Specialized AI assistants with tailored expertise | `agents/*.agent.md` |
| **Skills** | Discrete callable capabilities with bundled resources | `skills/*/SKILL.md` |
| **Hooks** | Event handlers that intercept agent behavior | `hooks.json` or `hooks/` |
| **MCP Servers** | Model Context Protocol integrations for external tools | `.mcp.json` or `.github/mcp.json` |
| **LSP Servers** | Language Server Protocol integrations | `lsp.json` or `.github/lsp.json` |

A plugin might include all of these or just one — for example, a plugin could provide a single specialized agent, or an entire development toolkit with multiple agents, skills, hooks, and MCP server configurations working together.

### Example: What a Plugin Looks Like

Here's the structure of a typical plugin:

```
my-plugin/
├── .github/
│   └── plugin/
│       └── plugin.json        # Plugin manifest (name, description, version)
├── agents/
│   ├── api-architect.agent.md
│   └── test-specialist.agent.md
├── skills/
│   └── database-migrations/
│       ├── SKILL.md
│       └── scripts/migrate.sh
├── hooks.json
└── README.md
```

The `plugin.json` manifest declares what the plugin contains:

```json
{
  "name": "my-plugin",
  "description": "API development toolkit with specialized agents and migration skills",
  "version": "1.0.0",
  "agents": [
    "./agents/api-architect.md",
    "./agents/test-specialist.md"
  ],
  "skills": [
    "./skills/database-migrations/"
  ]
}
```

## Why Use Plugins?

You might wonder: why not just copy agent files into your project manually? Plugins provide several advantages:

| Feature | Manual Configuration | Plugin |
|---------|---------------------|--------|
| **Scope** | Single repository | Any project |
| **Sharing** | Manual copy/paste | `copilot plugin install` command |
| **Versioning** | Git history | Marketplace versions |
| **Discovery** | Searching repositories | Marketplace browsing |
| **Updates** | Manual tracking | `copilot plugin update` |

Plugins are especially valuable when you want to:

- **Standardize across a team** — Everyone installs the same plugin for consistent tooling
- **Share domain expertise** — Package a Rails expert, Kubernetes specialist, or security reviewer as an installable unit
- **Encapsulate complex setups** — Bundle MCP server configurations that would otherwise require manual setup
- **Reuse across projects** — Install the same capabilities in every project without duplicating files

## Finding Plugins

Plugins are collected in **marketplaces** — registries you can browse and install from. Both Copilot CLI and VS Code come with two marketplaces registered by default — **no setup required**:

- **`copilot-plugins`** — Official GitHub Copilot plugins
- **`awesome-copilot`** — Community-contributed plugins from this repository

### Browsing in Copilot CLI

List your registered marketplaces:

```bash
copilot plugin marketplace list
```

Browse plugins in a specific marketplace:

```bash
copilot plugin marketplace browse awesome-copilot
```

Or from within an interactive Copilot session:

```
/plugin marketplace browse awesome-copilot
```

> **Tip**: You can also browse plugins on this site's [Plugins Directory](../../plugins/) to see descriptions, included agents, and skills before installing.

### Browsing in VS Code

Because `awesome-copilot` is a default marketplace in VS Code, you can discover plugins without any configuration:

- Open the **Extensions** search view and type **`@agentPlugins`** to see all available plugins
- Or open the **Command Palette** (`Ctrl+Shift+P` / `Cmd+Shift+P`) and run **Chat: Plugins**

### Adding More Marketplaces

Register additional marketplaces from GitHub repositories:

```bash
copilot plugin marketplace add anthropics/claude-code
```

Or from a local path:

```bash
copilot plugin marketplace add /path/to/local-marketplace
```

### Sharing Marketplace Registrations Across a Team

To automatically register an additional marketplace for everyone working in a repository, add an `extraKnownMarketplaces` entry to your `.github/copilot-settings.json` (or `config.json`):

```json
{
  "extraKnownMarketplaces": [
    {
      "name": "my-org-plugins",
      "source": "my-org/internal-plugins"
    }
  ]
}
```

With this in place, team members automatically get the `my-org-plugins` marketplace available without running a separate `marketplace add` command. This replaces the older `marketplaces` setting, which was removed in v1.0.16.

## Installing Plugins

### From Copilot CLI

Reference a plugin by name and marketplace:

```bash
copilot plugin install database-data-management@awesome-copilot
```

Or from an interactive session:

```
/plugin install database-data-management@awesome-copilot
```

> **Deprecation notice**: Installing plugins directly from a GitHub repository URL, raw URL, or local file path (e.g., `copilot plugin install github/awesome-copilot`) is deprecated and will be removed in a future release. Use marketplace-based installation instead.

### From VS Code

Browse to the plugin via `@agentPlugins` in the Extensions search view or via **Chat: Plugins** in the Command Palette, then click **Install**.

## Managing Plugins

Once installed, plugins are managed with a few simple commands:

```bash
# List all installed plugins
copilot plugin list

# Update a plugin to the latest version
copilot plugin update my-plugin

# Refresh all marketplace catalogs (fetch the latest list of available plugins)
copilot plugin marketplace update

# Remove a plugin
copilot plugin uninstall my-plugin
```

### Loading Plugins from a Local Directory

You can load plugins directly from a local directory without installing them from a marketplace, using the `--plugin-dir` flag when starting Copilot:

```bash
copilot --plugin-dir /path/to/my-plugin
```

Plugins loaded this way appear in `/plugin list` under a separate **External Plugins** section, clearly distinguished from marketplace-installed plugins. This is useful for testing local plugins in development or loading private plugins that aren't published to any marketplace.

### Where Plugins Are Stored

- **Marketplace plugins**: `~/.copilot/installed-plugins/MARKETPLACE/PLUGIN-NAME/`
- **Direct installs**: `~/.copilot/installed-plugins/_direct/PLUGIN-NAME/`

## How Plugins Work at Runtime

When you install a plugin, its components become available to Copilot CLI automatically:

- **Agents** appear in your agent selection (use with `/agent` or the agents dropdown)
- **Skills** are loaded automatically when relevant to your current task
- **Hooks** run at the configured lifecycle events during agent sessions
- **MCP servers** extend the tools available to agents

You don't need to do any additional configuration after installing — the plugin's components integrate seamlessly into your workflow. Plugins take effect immediately after installation without requiring a Copilot CLI restart.

## Plugins from This Repository

This repository (`awesome-copilot`) serves as both a collection of individual resources _and_ a plugin marketplace. You can use it in two ways:

### Install Individual Plugins

Browse the [Plugins Directory](../../plugins/) and install specific plugins:

```bash
copilot plugin install context-engineering@awesome-copilot
copilot plugin install azure-cloud-development@awesome-copilot
copilot plugin install frontend-web-dev@awesome-copilot
```

Each plugin bundles related agents and skills around a specific theme or technology.

### Use Individual Resources Without Plugins

If you only need a single agent or skill (rather than a full plugin), you can still copy individual files from this repo directly into your project:

- Copy an `.agent.md` file into `.github/agents/`
- Copy a skill folder into `.github/skills/`
- Copy a hook configuration into `.github/hooks/`

See [Using the Copilot Coding Agent](../using-copilot-coding-agent/) for details on this approach.

## Best Practices

- **Start with a marketplace plugin** before building your own — there may already be one that fits your needs
- **Keep plugins focused** — a plugin for "Rails development" is better than a plugin for "everything"
- **Check for updates regularly** — run `copilot plugin update` to get the latest improvements
- **Review what you install** — plugins run code on your machine, so inspect unfamiliar plugins before installing
- **Use plugins for team standards** — publish an internal plugin to ensure every team member has the same agents, skills, and hooks
- **Remove unused plugins** — declutter with `copilot plugin uninstall` to keep your environment clean

## Common Questions

**Q: Do plugins work with the coding agent on GitHub.com?**

A: Plugins are specific to GitHub Copilot CLI and the VS Code extension (currently Insiders). For the coding agent on GitHub.com, add agents, skills, and hooks directly to your repository (via a plugin if you prefer!). See [Using the Copilot Coding Agent](../using-copilot-coding-agent/) for details.

**Q: Can I use plugins and repository-level configuration together?**

A: Yes. Plugin components are merged with your repository's local agents, skills, and hooks. Local configuration takes precedence if there are conflicts.

**Q: How do I create my own plugin?**

A: Create a directory with a `plugin.json` manifest and your agents/skills/hooks. See the [GitHub docs on creating plugins](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/plugins-creating) for a step-by-step guide.

**Q: Can I share plugins within my organization?**

A: Yes. You can create a private plugin marketplace in an internal GitHub repository, then have team members register it with `copilot plugin marketplace add org/internal-plugins`.

**Q: What happens if I uninstall a plugin?**

A: The plugin's agents, skills, and hooks are removed from Copilot, and any cached plugin data stored on disk is also cleaned up. Any work already done with those tools is unaffected — only future sessions lose access.

## Next Steps

- **Browse Plugins**: Explore the [Plugins Directory](../../plugins/) for installable plugin packages
- **Create Skills**: [Creating Effective Skills](../creating-effective-skills/) — Build skills that can be included in plugins
- **Build Agents**: [Building Custom Agents](../building-custom-agents/) — Create agents to package in plugins
- **Add Hooks**: [Automating with Hooks](../automating-with-hooks/) — Configure hooks for plugin automation

---