⚡ Agents, Skills & Advanced Features¶

The Big Picture — Three Types of Superpowers¶

Copilot CLI doesn't work alone. It gets help from three types of assistants — each with a different superpower. Understanding these three is the key to unlocking everything Copilot can do.

Type	Icon	What It Is	Café Analogy
Skills	🎯	Built-in recipes Copilot already knows	Recipe cards the manager already has memorised
Plugins	🔌	Add-on gadgets you connect from outside	Kitchen gadgets you buy and plug in
MCP Servers	🌐	External services connected via a protocol	Suppliers connected by phone — you call them when you need ingredients

┌─────────────────────────────────────────────────┐
│              YOU  (ask a question)               │
├─────────────────────────────────────────────────┤
│          GitHub Copilot CLI  (the brain)         │
├────────┬────────────────┬───────────────────────┤
│ Skills │    Plugins     │     MCP Servers        │
│  🎯    │      🔌        │        🌐              │
│ Built  │  Connected     │  External services     │
│  -in   │  add-ons       │  (Azure, M365, etc.)   │
└────────┴────────────────┴───────────────────────┘

The simple rule

Skills = things Copilot already knows how to do. Plugins = extra abilities you give it. MCP Servers = live connections to real services that do the actual work.

Skills 🎯 — Built-In Recipes¶

Skills are pre-installed capabilities that Copilot can use immediately. You don't install them — they're already there. When you ask a question, Copilot automatically picks the right skill for the job.

How Skills Work¶

  You ask naturally          Copilot picks the        Skill does           Results come
  in plain English     →     right skill          →   the work         →   back to you
  ─────────────────          ────────────────         ──────────           ──────────────
  "Show me my                Picks: org-chart         Queries M365         Beautiful ASCII
   org chart"                                         Graph API            tree appears

You don't need to name the skill

Just describe what you want. Copilot figures out which skill to use. If you want to be specific, you can say "use the org-chart skill" — but it's not required.

Productivity & M365 Skills¶

These skills connect to your Microsoft 365 environment — emails, meetings, Teams, SharePoint, and more.

Skill	What It Does	Example Prompt
`workiq`	Ask about emails, meetings, Teams messages, and documents	"What did John email me about last week?"
`daily-outlook-triage`	Get a summary of your inbox + calendar for the day	"Triage my day"
`email-analytics`	Analyse email volume, top senders, busiest days	"Show my email patterns this month"
`meeting-cost-calculator`	Calculate time spent in meetings (hours, % of work time)	"How much time did I spend in meetings last week?"
`channel-audit`	Find inactive or low-engagement Teams channels	"Which Teams channels are inactive?"
`channel-digest`	Summarise activity across multiple Teams channels	"Summarise the Engineering channel this week"
`action-item-extractor`	Pull action items with owners and deadlines from meeting content	"Extract action items from yesterday's standup"
`org-chart`	Display an ASCII org chart for anyone in your organisation	"Show me Sarah's org chart"
`site-explorer`	Browse SharePoint sites, document libraries, and files	"What sites do I have access to?"
`multi-plan-search`	Search tasks across all your Planner plans at once	"Find all tasks assigned to me across all plans"

Development & Azure Skills¶

These skills help with coding, security, cloud resources, and AI agent development.

Skill	What It Does	Example Prompt
`azure-deploy`	Provision Azure resources, deploy apps, set up CI/CD pipelines	"Deploy this app to Azure"
`security-scanner`	Scan repos for vulnerabilities, exposed secrets, dependency risks	"Scan this repo for security issues"
`data-ai-toolkit`	Data cleaning, transformation, ML model evaluation	"Validate this CSV dataset"
`declarative-agent-developer`	Create, build, and deploy M365 Copilot agents	"Create a new declarative agent"
`ui-widget-developer`	Build MCP servers with rich widget rendering for Copilot Chat	"Build an MCP server for Copilot"
`install-atk`	Install or update the M365 Agents Toolkit (ATK) CLI and VS Code extension	"Install the agents toolkit"

Plugins 🔌 — Add-On Gadgets¶

Plugins are external capabilities that you connect from outside. They bring in powers from other services that Copilot doesn't have built-in.

Skills vs Plugins — What's the Difference?¶

	Skills 🎯	Plugins 🔌
Where they live	Built into Copilot	Connected from outside
Internet needed?	Some work offline	Always need internet
Login needed?	Usually not	Usually yes (OAuth, API key, etc.)
Installation	Already there	You add them via `/plugin`
Analogy	Pre-installed apps on your phone	Apps you download from the store
Updates	Updated with Copilot itself	Updated independently

Phone analogy

Your phone comes with a Calculator app (that's a skill). You download Uber from the app store (that's a plugin). Calculator works anywhere. Uber needs internet, your location, and a login.

Managing Plugins¶

/plugin          # Browse and install available plugins
/skills          # See all skills (both built-in and from plugins)

MCP Servers 🌐 — External Service Connections¶

If you've already read the MCP section, you know the basics. Here's a quick recap with how it fits into the bigger picture.

MCP (Model Context Protocol) servers are live connections to external services. They let Copilot actually do things in real systems — not just talk about them.

Your Current MCP Servers¶

MCP Server	What It Connects To	What You Can Do
`m365-admin-graph`	Lab tenant (M365CPI52224224)	List users, check licenses, view admin roles, service health
`azure`	Azure subscription	Create/manage Azure resources, check quotas, deploy apps
`github-mcp-server`	GitHub	Search repos, read PRs/issues, view commits, manage actions

How MCP Fits with Skills & Plugins¶

┌──────────────────────────────────────────────────────┐
│  Skill: "azure-deploy"                               │
│  (The recipe — knows HOW to deploy)                  │
│         │                                            │
│         ▼                                            │
│  MCP Server: "azure"                                 │
│  (The connection — actually DOES the deploy)         │
│         │                                            │
│         ▼                                            │
│  Azure Cloud                                         │
│  (The real service — where resources live)            │
└──────────────────────────────────────────────────────┘

Skills need MCP to do real work

A skill is like a recipe (instructions). An MCP server is like the kitchen (equipment + ingredients). The recipe tells you how to make the dish, but you need the kitchen to actually cook it.

How All Three Work Together 🤝¶

The real power comes when skills, plugins, and MCP servers combine to answer a single request. Copilot orchestrates them automatically.

Combined Example

You ask: "Check my Azure resources, scan for security issues, and find any emails about the outage last week."

Copilot breaks this into three parallel tasks:

Step	Tool Used	Type
1. Check Azure resources	`azure` MCP server	🌐 MCP
2. Scan for security	`security-scanner` skill	🎯 Skill
3. Find outage emails	`workiq` plugin/skill	🔌 Plugin

All three run, and Copilot combines the results into one coherent answer.

    Your question
         │
    ┌────┴────────────────────────────────────┐
    │         Copilot CLI (orchestrator)       │
    ├────────────┬──────────────┬──────────────┤
    │   🌐 MCP   │  🎯 Skill    │  🔌 Plugin   │
    │   Azure    │  Security    │  WorkIQ      │
    │   check    │  scan        │  email       │
    │   resources│  codebase    │  search      │
    ├────────────┴──────────────┴──────────────┤
    │         Combined answer to you           │
    └──────────────────────────────────────────┘

Agents 🤖 — Copilot's Workforce¶

This is where things get really interesting. Agents are mini-workers that Copilot sends out to do specific jobs — like a head chef delegating tasks to a team of sous chefs.

Sub-Agents (Built-In Workers)¶

Copilot has four types of built-in sub-agents, each specialised for a different kind of work:

Agent	Role	What It Does	Analogy
Explore	🔍 Scout	Searches and understands code quickly, answers questions about a codebase	Scout who runs ahead to check what's in a new building
Task	🔨 Worker	Runs commands — build, test, install, lint	Builder who follows the blueprint and hammers nails
General-purpose	👨‍💼 Senior Staff	Handles complex, multi-step work that needs judgement	Senior engineer who can design and build
Code-review	🔎 Inspector	Reviews code for bugs, security issues, logic errors	Quality inspector checking the finished product

Without Agents vs With Agents¶

WITHOUT agents (one chef does everything):
┌────────────┐   ┌────────────┐   ┌────────────┐
│  Task 1    │──▶│  Task 2    │──▶│  Task 3    │
│  (3 min)   │   │  (3 min)   │   │  (3 min)   │
└────────────┘   └────────────┘   └────────────┘
Total: 9 minutes (sequential)

WITH agents (head chef delegates to sous chefs):
┌────────────┐
│  Task 1    │──┐
│  (3 min)   │  │
├────────────┤  ├──▶  All done in 3 minutes!
│  Task 2    │  │
│  (3 min)   │  │
├────────────┤  │
│  Task 3    │──┘
│  (3 min)   │
└────────────┘
Total: 3 minutes (parallel)

You don't control agents directly

Copilot decides when to use sub-agents automatically. When you ask a complex question, it might spin up an explore agent to search your code, a task agent to run a build, and a code-review agent to check the results — all behind the scenes.

Custom Agents (You Create!) ✨¶

Custom agents are instruction files that change how Copilot behaves. Same AI brain, different behaviour — like an actor reading from a different script.

Where Custom Agent Files Live¶

File / Location	Scope	When It's Used
`AGENTS.md` (project root)	Whole project	Every conversation in this project
`.github/copilot-instructions.md`	Whole project	Every conversation (GitHub convention)
`.github/instructions/*.instructions.md`	Specific patterns	When working on matching files

Same AI, different behaviour

A custom agent doesn't replace Copilot — it shapes it. Think of it like giving a new employee a handbook for your specific workplace. The employee is the same person, but they behave differently based on the handbook they've read.

Example: A Simple AGENTS.md¶

Here's what an AGENTS.md file might look like for a café documentation project:

# Project Instructions

## Who You Are
You are a friendly documentation assistant for Café Clawy.
All documentation is written for non-technical café staff.

## Style Rules
- Use simple language — no jargon
- Always include real-world analogies
- Format information as tables when comparing things
- Use emoji to make headings scannable
- Keep paragraphs under 3 sentences

## Content Rules
- Explain the "why" before the "how"
- Include a "Common Mistakes" section in every guide
- Always test instructions by reading them as a complete beginner

How Custom Agents Work¶

Session starts
      │
      ▼
Copilot loads AGENTS.md        ← reads the "handbook"
      │
      ▼
Every response follows         ← acts according to
the instructions                  the handbook rules
      │
      ▼
You get consistently           ← same tone, same format,
styled responses                  every time

Custom agents are per-project

Your AGENTS.md only works when you're inside that project folder. Move to a different folder and Copilot goes back to its default behaviour — like a chef who only follows a specific restaurant's recipe book when they're in that restaurant.

Advanced Features 🚀¶

These are the "power user" features that take Copilot from a helpful assistant to a full productivity powerhouse.

/delegate 📤 — Send Work to GitHub Cloud¶

What it does: Takes your current conversation and sends it to GitHub's cloud, where Copilot autonomously creates a Pull Request with the changes.

You describe the task
        │
        ▼
/delegate sends it          ← like sending an order
to GitHub cloud                to the central kitchen
        │
        ▼
Copilot works on it         ← in the cloud, on its own
autonomously
        │
        ▼
Pull Request created        ← finished dish delivered
on GitHub                      back to you for approval

Requirements for /delegate

Your project must be a Git repository connected to GitHub
The work must be clear enough for Copilot to do independently
You'll review the Pull Request before merging — Copilot doesn't push to production

When to use /delegate

"Add a footer to every page in my documentation site with a copyright notice and last-updated date."

Instead of doing this manually across 20 files, /delegate lets Copilot do it in the cloud and present you with a clean PR to review.

/research 🔍 — Deep Research Agent¶

What it does: Launches a deep research agent that searches GitHub + the web, reads 10–20 sources, and comes back with a comprehensive report with citations.

Normal question:    "What is Terraform?"
                     → Quick answer from memory (30 seconds)

/research question: "What are the latest best practices for
                     Terraform state management in 2025?"
                     → Searches 10-20 sources, reads them,
                       compares information, brings back a
                       full report with links (2-5 minutes)

Use /research for...	Don't use /research for...
Blog or video research	Simple factual questions
"What's new in Kubernetes 1.32?"	"How do I list files in PowerShell?"
Comparing technologies	Quick daily tasks
Finding best practices with sources	Things you already know the answer to
Market research on tools	Checking the weather

The supplier visit analogy

Normal Copilot is like asking a colleague who might know the answer. /research is like visiting 10 different suppliers, reading their reviews, comparing prices, tasting samples, and bringing back a full procurement report with sources.

/fleet ⚡ — Parallel Agents¶

What it does: Launches multiple sub-agents simultaneously to work on different parts of a task at the same time.

WITHOUT /fleet (sequential):
┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│ Update docs  │────▶│ Fix styling  │────▶│ Add tests    │
│   3 min      │     │   3 min      │     │   3 min      │
└──────────────┘     └──────────────┘     └──────────────┘
                Total: ~9 minutes

WITH /fleet (parallel):
┌──────────────┐
│ Update docs  │ ─┐
│   3 min      │  │
├──────────────┤  ├──▶  Total: ~3 minutes
│ Fix styling  │  │
│   3 min      │  │
├──────────────┤  │
│ Add tests    │ ─┘
│   3 min      │
└──────────────┘

When Copilot uses parallel agents automatically

Even without explicitly typing /fleet, Copilot sometimes spins up parallel sub-agents on its own when it detects that parts of your task are independent. /fleet is for when you know you want parallelism upfront.

Other Useful Advanced Commands¶

Command	What It Does	Analogy
`/diff`	Shows all changes Copilot has made in this session	📋 Checking the receipt before paying
`/rewind` or `/undo`	Takes back the last action Copilot performed	⏪ The undo button — goes back one step
`/pr`	Work with GitHub Pull Requests (create, view, review)	📬 Managing your mailbox of code changes
`/review`	Run a code review on current changes	🔎 Having a colleague double-check your work
`/init`	Set up Copilot instructions for a new project	📝 Writing the employee handbook for a new restaurant

The safety net commands

/diff and /rewind are your safety net. Always check /diff before committing changes, and use /rewind if Copilot did something unexpected. It's like having an undo button and a receipt printer — use them liberally.

The Power Combo — Content Creation Pipeline 🏗️¶

Here's where everything comes together. Imagine you want to go from zero to published article entirely from the terminal. Here's the pipeline:

Step 1                Step 2              Step 3
┌──────────────┐     ┌──────────────┐    ┌──────────────┐
│  /research   │────▶│  Write the   │───▶│  /review     │
│  latest      │     │  blog post   │    │  check       │
│  updates     │     │  using facts │    │  quality     │
│  📚 Get facts│     │  ✍️ Create   │    │  🔎 QA pass  │
└──────────────┘     └──────────────┘    └──────────────┘
                                               │
                          ┌────────────────────┘
                          ▼
Step 4                Step 5              Step 6
┌──────────────┐     ┌──────────────┐    ┌──────────────┐
│  /delegate   │────▶│  Review &    │───▶│  Deploy      │
│  send to     │     │  merge the   │    │  publish     │
│  GitHub      │     │  PR          │    │  the site    │
│  📤 Create PR│     │  ✅ Approve  │    │  🚀 Go live! │
└──────────────┘     └──────────────┘    └──────────────┘

Step	Command	What Happens	Time
1	`/research latest updates on Azure Container Apps 2025`	Searches 10+ sources, returns report with citations	~3 min
2	"Write a blog post based on this research"	Copilot drafts a full article using the research	~2 min
3	`/review`	Code-review agent checks quality, grammar, accuracy	~1 min
4	`/delegate`	Sends to GitHub cloud → creates a Pull Request	~2 min
5	Review the PR on GitHub	You read and approve the changes	~5 min
6	Merge → auto-deploy	Site rebuilds and publishes	~1 min

From research to published article in ~15 minutes

The entire pipeline — research, writing, review, Pull Request, approval, and deployment — happens without leaving the terminal. That's the power of skills, agents, and advanced features working together.

Quick Reference — Everything at a Glance¶

Feature	Command/Concept	One-Line Summary
Skills	Auto-detected	Built-in recipes Copilot already knows
Plugins	`/plugin`	Add-on capabilities from external services
MCP Servers	`/mcp`	Live connections to real services (Azure, M365, GitHub)
Sub-Agents	Auto-managed	Mini-workers Copilot delegates to behind the scenes
Custom Agents	`AGENTS.md`	Instruction files that shape Copilot's behaviour
/delegate	`/delegate`	Send work to GitHub cloud → get a Pull Request back
/research	`/research`	Deep research with citations from 10+ sources
/fleet	`/fleet`	Run multiple agents in parallel for speed
/diff	`/diff`	See all changes made in this session
/rewind	`/rewind`	Undo the last action
/review	`/review`	Run code review on changes
/init	`/init`	Set up Copilot instructions for a project

The big takeaway

Copilot CLI isn't just a chatbot — it's a command centre with an army of specialised workers (agents), a toolbox of built-in recipes (skills), connections to the real world (MCP), and powerful commands that automate entire workflows. The more you use these features together, the more powerful it becomes.