GitHub Copilot Agents vs Skills: What Each One Is

In GitHub Copilot, a custom agent is a role and a skill is a procedure. A custom agent, an .agent.md file, combines instructions, a list of allowed tools and optionally a model into something you pick from the agent dropdown, such as a planner that can only read or a reviewer that cannot edit. A skill, a folder with a SKILL.md file, is a set of instructions, and often scripts or templates, that whichever agent is working loads when the task matches, or that you call with a slash. So the question to ask is: do I want a different worker, or do I want the current worker to know how to do one thing properly? A different worker is an agent. Knowing how is a skill. They are designed to be used together, not instead of each other.

What a custom agent is

VS Code’s documentation on custom agents↗ (opens in a new tab) defines them as instructions, tools and an optional language model combined into a reusable configuration for a specific role, such as planning or code review. They used to be called custom chat modes; only the name changed.

• Where they live: .github/agents/ in the workspace, .claude/agents/ for the Claude format, or ~/.copilot/agents/ for yourself.
• What the frontmatter sets: description, name, tools, model, handoffs to suggest the next agent, agents to list which agents it may run as subagents, mcp-servers, and target for VS Code or GitHub.
• How it is used: you select it in the agent dropdown, another agent delegates to it as a subagent, or a handoff button moves you to it. user-invocable: false hides it from the dropdown so it is used only as a subagent.
• What makes it an agent: the tools list. A reviewer with no edit tools cannot edit, whatever its instructions say. To give it every tool from one MCP server, use <server>/*.

What a skill is

VS Code’s page on agent skills↗ (opens in a new tab) calls them folders of instructions, scripts and resources that Copilot can load when relevant to perform specialised tasks. The folder holds a SKILL.md with a name and a description of what it does and when to use it, and anything else the procedure needs.

• Where they live: .github/skills/, .claude/skills/ or .agents/skills/ in the project, or ~/.copilot/skills/ and the matching folders in your home directory.
• How it loads, in three stages: Copilot reads only the name and description at first, loads the body of SKILL.md when the task matches or you call it, and opens the extra files only when the instructions refer to them.
• How you call it: type / and its name, with context after it. disable-model-invocation: true means it runs only when you call it; user-invocable: false keeps it out of the slash menu so only the agent decides.
• What it does not do: change the tools. A skill runs with whatever tools the current agent has.

Side by side

• The question it answers. Agent: who is doing this, and with what? Skill: how is this particular job done here?
• Who switches it on. Agent: you pick it, or another agent delegates to it. Skill: the current agent loads it when the task matches its description, or you call it.
• What it contains. Agent: a system prompt, a tool list, a model and handoffs. Skill: instructions plus files, such as a script, a template or an example.
• What it changes. Agent: the whole session, including what can be done. Skill: what the agent knows for this task only.
• What it costs. Agent: its instructions apply for as long as it is selected, and every tool it lists is a description the model reads. Skill: a line of name and description until it is used.
• Where else it works. Agents and skills both work beyond VS Code, covered below; skills also follow an open standard used by other assistants.

Where instructions and prompt files fit

Agents and skills are two of several ways to shape Copilot, and half the confusion comes from the other two. VS Code’s overview of customisation types↗ (opens in a new tab) gives each a one-line purpose, and it is the clearest way to place them:

• Custom instructions apply standards across a project, and are included in every request automatically. “Use this logging library” belongs here.
• Prompt files run a saved task on demand, as a slash command. “Scaffold a component” belongs here, if it needs no files of its own.
• Agent skills teach the agent a workflow with supporting resources, loaded when the task matches or when you call it. “Create a service from these templates and this setup script” belongs here.
• Custom agents give you a specialised role and tool configuration. “Review code with read-only tools” belongs here.

Prompt files and skills overlap the most, since both can be called with a slash. The difference is that a skill can carry files and can be loaded by the agent without being asked. For a step-by-step view of every lever and what it costs in context, see context engineering with GitHub Copilot.

When to use which

• You want Copilot unable to do something: an agent. Only a tool list takes a capability away; a skill that says “do not edit” is a request.
• You keep explaining the same procedure: a skill. Release notes, a migration checklist, how to add an endpoint in this codebase.
• The procedure needs a script or a template: a skill, because it can carry them.
• You want a different model for one kind of work: an agent, because the model is set per agent.
• You want a sequence, such as plan, then implement, then review: agents with handoffs, each using whichever skills apply.
• It is a rule for every request: neither. It is a custom instruction.

Using both together

The common pattern is a small number of agents that differ by what they may do, and a larger number of skills that any of them can use. A triage agent that can read the code and write to the task board, but not edit files, is an agent. The way this team writes up a bug, with its template, is a skill that agent loads.

---
description: "Reads new reports, reproduces them, files tasks. Never edits code."
tools: ['search/codebase', 'search/usages', 'fenbs/*']
---
For each report: find the code involved, try to reproduce it,
then file one task using the bug-report skill. Do not change any file.

---
name: bug-report
description: "How to write up a bug as a task: use when filing or triaging a bug."
---
Title: what is wrong, in the user's words.
Note: steps to reproduce, expected, actual, and file:line where it goes wrong.
Search the board first (fenbs_search); comment on a match instead of filing twice.
File with fenbs_create_item, kind bug. Leave the plan empty unless the fix is known.

Each piece does one job. The agent file decides what can happen. The skill decides how it is done, and the same skill works for the default agent, or for Claude Code, which reads .claude/skills/ too.

Beyond VS Code

GitHub’s page about agent skills↗ (opens in a new tab) says skills work with Copilot cloud agent, Copilot code review, the Copilot CLI, the Copilot app, and agent mode in VS Code and JetBrains IDEs, and notes that the skills specification is an open standard used by other AI systems. For the Claude side of the same idea, and how skills differ from connecting a tool, see MCP vs skills.

Custom agents travel too. GitHub’s page about custom agents↗ (opens in a new tab) describes agent profiles in .github/agents/ in a repository, or in an organisation’s .github or .github-private repository to share them, used by the cloud agent on GitHub.com, in IDEs, in the Copilot app and in the CLI. Tool names differ between environments, so check a profile’s tools list when you move it from VS Code to GitHub.

What neither one holds

Agents and skills are both about how work is done. Neither records what is being done, what was decided, or what the last session left unfinished; that lives outside the chat. On fenbs it lives on the board, which an agent reaches over MCP, and the two kinds of limit stack. The agent’s tools list decides which of the board’s tools Copilot is offered. The scopes ticked at sign-in, and your role on the board, decide what those tools are allowed to do. A triage agent with fenbs/* still cannot move a task if the sign-in did not include write. Every change is recorded with the assistant’s name. For skills written around a board, see Claude skills for project management.