GitHub Copilot Chat has quickly evolved from a simple coding assistant into something much more powerful. With the introduction of agents, prompts, and tools, developers can now build structured workflows that allow Copilot to perform complex tasks inside a project.

One question that often comes up is this:

When should you create a custom agent instead of just using a custom prompt?

At first glance it might seem unnecessary. If you already have a custom prompt like /create-instructions, why not just run it using the default Copilot agent?

The answer comes down to context control, tool access, and token efficiency.

The Problem With the Default Agent

The default Copilot Chat agent has access to every available tool in your environment.

This can include things like:

• filesystem access
• terminal commands
• web access
• MCP tools
• info about custom agents, prompts, and instructions
• +more

This sounds powerful, and it is. But it also creates a subtle problem.

When Copilot runs a task, it needs to consider the tools that are available to it. Each tool includes metadata, descriptions, and usage instructions that are injected into the context window.

That means the model is processing a LOT more information than it actually needs.

More tools means:

• more context loaded
• more tokens consumed
• more potential confusion for the model

This is what many developers call context pollution.

The model has to think about tools that are completely irrelevant to the task you are asking it to perform.

A Simple Example: The Instructions Generator

Imagine you want to create an agent that generates project instruction files such as:

• AGENTS.md
• CLAUDE.md
• .github/copilot-instructions.md
• .github/instructions/database-interactions.instructions.md

You might create a custom prompt like this:

/create-instructions (.github/prompts/create-instructions.prompt.md)

---
agent: Instructions Generator
---

Take the information below and generate a `[NAME].instructions.md`
file for it in the `/.github/instructions` directory.
Generate an appropriate name for the `[NAME]` placeholder based on
the generated content. Make sure the instructions are concise and not too long.
If no information is provided below, prompt the user to give
the necessary details about the layer of architecture or coding standards to document.
The .md file should have frontmatter with a description property
that informs copilot of when to use this set of instructions.

The prompt might analyze your project and generate instructions that help AI tools work more effectively inside your repository.

You could run this prompt using the default agent.

But the default agent still has access to everything:

• filesystem access
• terminal commands
• web access
• MCP tools
• info about custom agents, prompts, and instructions

A lot of these are actually required for generating an instructions file.

The Better Approach: A Custom Agent

Instead of using the default agent, you can create a custom agent specifically designed for this task.

The custom agent might only enable a small set of tools, such as:

• read files
• list directories
• search code

That’s it.

Now the agent has exactly what it needs to understand the project structure and generate instructions.

Nothing more.

Why This Matters

By restricting the tools available to the agent, several good things happen.

1. Smaller Context Window Usage

Every enabled tool contributes data to the context window.

If you reduce the tool list from twenty tools down to three, you dramatically reduce the amount of context the model needs to process.

This means:

• fewer tokens
• lower API cost
• faster responses

In large projects this can make a significant difference.

2. Less Context Pollution

Large context windows often introduce noise.

If the model sees tools related to:

• shell execution
• database access
• deployment
• git operations

it may try to use them even when they are irrelevant.

This can lead to unnecessary tool calls or overly complex reasoning paths.

A smaller toolset keeps the agent focused on the job it was designed to do.

3. More Reliable Outputs

Agents perform best when their environment is well constrained.

When an agent only has access to the tools it actually needs, it is more likely to produce predictable and consistent results.

This is especially important for repeatable workflows such as:

• generating documentation
• producing instruction files
• scaffolding project structures
• analyzing repositories

In other words, the agent becomes SPECIALIZED instead of generic.

Custom Agents Are Like Microservices

A useful way to think about agents is similar to microservices in software architecture.

Instead of one massive agent that does everything, you create smaller agents that each perform a very specific job.

For example:

• an instructions generator agent
• a documentation agent
• a refactoring agent
• a database query agent

Each one has:

• its own set of prompts
• its own tool access
• its own narrow purpose

This leads to cleaner workflows and far more predictable behavior.

When You Should Use a Custom Agent

A custom agent is usually the right choice when:

• the task has a clearly defined purpose
• only a small number of tools are required
• you want consistent repeatable outputs
• token efficiency matters
• you want to avoid unnecessary tool usage

If the workflow is broad or exploratory, the default agent may still make sense.

But if you are building structured developer workflows, custom agents are almost always the better option.

Final Thoughts

Custom prompts are useful, but they are only part of the equation.

If you run those prompts with the default Copilot agent, you are still carrying the overhead of every available tool in your environment.

Custom agents allow you to control that environment.

By carefully selecting the tools an agent can use, you reduce context size, reduce token usage, and improve the quality of the results.

In practice this means your AI workflows become faster, cheaper, and far more reliable.

And that is exactly what you want when building serious AI powered developer tooling.