Use built-in and custom agents with GitHub Copilot

Visual Studio includes a set of curated built-in agents that integrate deeply with IDE capabilities like debugging, profiling, and testing. You can also create custom agents tailored to how your team works.

Prerequisites

• Visual Studio 2022 version 17.14 or later
• A GitHub Copilot subscription

Access custom agents

Built-in agents

Each built-in agent is designed around a specific developer workflow and integrates with Visual Studio's native tooling in ways that a generic assistant can't.

Use the @profiler agent

The @profiler agent connects to Visual Studio's profiling tools to help identify and fix performance issues.

Example prompts:

• @profiler Find the performance bottlenecks in my application
• @profiler Why is this method taking so long to execute?
• @profiler Suggest optimizations for the hot path

Custom agents

The built-in agents cover common workflows, but your team knows your workflow best. Custom agents let you build your own using the same foundation: workspace awareness, code understanding, your preferred AI model, and your own tools.

Custom agents become especially powerful when combined with MCP (Model Context Protocol). You can connect agents to external knowledge sources like internal documentation, design systems, APIs, and databases, so the agent isn't limited to what's in your repository.

Create a custom agent

Custom agents are defined as .agent.md files in your repository's .github/agents/ folder:

your-repo/
└── .github/
    └── agents/
        └── code-reviewer.agent.md

Agent file format

Each agent file uses a simple template with YAML frontmatter followed by Markdown instructions:

---
name: Code Reviewer
description: Reviews PRs against our team's coding standards
model: claude-opus-4-6
tools: ["code_search", "readfile", "find_references"]
---

You are a code reviewer for our team. When reviewing changes, check for:

- Naming conventions: PascalCase for public methods, camelCase for private
- Error handling: all async calls must have try/catch with structured logging
- Test coverage: every public method needs at least one unit test

Flag violations clearly and suggest fixes inline.

Frontmatter properties

Specify tools

Tools extend what your custom agent can do. You can specify which tools the agent should use in the tools array.

Connect to external sources with MCP

With MCP servers, your custom agents can access external knowledge sources:

• Internal documentation and wikis
• Design systems and component libraries
• APIs and databases
• Style guides and ADR repositories

For example, a code review agent can check PRs against your actual conventions by connecting to your style guide via MCP.

Example custom agents

Code review agent

---
name: Code Reviewer
description: Reviews code against our team's coding standards
tools: ["code_search", "readfile"]
---

You are a code reviewer for our team. Review changes for:

1. **Naming conventions**: PascalCase for public methods, camelCase for private fields
2. **Error handling**: All async calls must have try/catch with structured logging
3. **Test coverage**: Every public method needs at least one unit test
4. **Documentation**: Public APIs must have XML documentation comments

Flag violations clearly and suggest fixes inline.

Planning agent

---
name: Feature Planner
description: Helps plan features before writing code
tools: ["code_search", "readfile", "find_references"]
---

You are a planning assistant. When asked about a feature:

1. Gather requirements by asking clarifying questions
2. Identify affected files and components in the codebase
3. Break down the work into discrete tasks
4. Flag potential risks or dependencies
5. Create a structured plan that can be handed off for implementation

Focus on understanding scope before suggesting solutions.

Design system agent

---
name: Design System
description: Enforces UI design patterns and component usage
tools: ["code_search", "readfile"]
---

You are a design system expert. When reviewing UI code:

1. Check that standard components are used instead of custom implementations
2. Verify spacing and layout follow the design token system
3. Ensure accessibility requirements are met (ARIA labels, keyboard navigation)
4. Flag any UI drift from established patterns

Reference the component library documentation when suggesting fixes.

Full-stack development agent with Visual Studio tools

The following example uses Visual Studio-specific tool names:

---
name: Full Stack Dev
description: Full-stack development assistant with search, file editing, and terminal access
tools: ["code_search", "readfile", "editfiles", "find_references", "runcommandinterminal", "getwebpages"]
---

You are a full-stack development assistant. Help with:

1. Searching the codebase to understand existing patterns
2. Reading and editing files to implement changes
3. Running build and test commands to verify your work
4. Looking up documentation when needed

Always check existing code conventions before making changes.

Community configurations

The awesome-copilot repository has community-contributed agent configurations you can use as starting points. When using configurations from this repository, verify tool names work in Visual Studio before deploying to your team.

Limitations and notes

• If you don't specify a model, the agent uses whatever model is selected in the model picker.
• Tool names vary across GitHub Copilot platforms. Verify tool names work in Visual Studio before deploying to your team.

Share feedback

Share your custom agent configurations in the awesome-copilot repository or file feedback through Visual Studio Developer Community. Your workflows help shape future features.

Related content

• Get started with GitHub Copilot agent mode
• Use MCP servers
• Customize chat responses and set context
• GitHub Copilot testing for .NET