Unlock VS Code's Agent Mode: Supercharge Your Coding with GitHub Copilot Tools

Agent mode in VS Code is transforming how developers interact with their coding environment. This powerful feature enables GitHub Copilot to not only suggest code but actively make edits and invoke specialized tools to help accomplish your requests. For developers looking to boost productivity and streamline their workflow, understanding how to leverage agent mode effectively is becoming essential.

GitHub Copilot's agent mode in action, helping implement a todo app with automated package installation via terminal commands

Understanding Agent Mode and Its Capabilities

Agent mode elevates GitHub Copilot from a simple code suggestion tool to a comprehensive AI coding assistant. In this mode, Copilot can autonomously edit your code and leverage various tools to help complete complex tasks. The real magic happens when Copilot combines its understanding of your codebase with these additional capabilities.

To access agent mode, simply switch to it in the Copilot chat interface and click the tools icon to view and manage available tools. This interface allows you to select which tools you want to make available to Copilot during your coding session.

Built-in Tools in GitHub Copilot Chat

Copilot comes with several powerful built-in tools that enhance its capabilities:

**Codebase tool**: References information directly from your project files
**Fetch tool**: Retrieves web data to provide as context for your queries
**Terminal command tool**: Executes terminal commands to automate environment setup and other tasks
**File operations**: Reads and modifies files within your project

You can reference these tools directly using hashtags (e.g., `#fetch https://example.com`) or through natural language (e.g., "fetch from webpage https://example.com"). The real power of agent mode is that Copilot can automatically determine when to invoke these tools based on your requests.

Extension-Provided Tools: Enhancing Agent Mode

VS Code's extensibility model allows third-party extensions to contribute additional tools to agent mode. One excellent example is the Prompt Boost extension, which enhances your prompts by adding relevant technical context, best practices, and specific requirements.

The Prompt Boost extension enhancing a Todo application prompt with detailed technical specifications and best practices for Vue.js implementation

With Prompt Boost installed, you can significantly improve the quality of your interactions with Copilot. For instance, a simple prompt to "create a to-do app" can be transformed into a detailed specification that includes framework preferences, component structure, and functionality requirements.

To use this extension in agent mode, you can either directly reference it with `#prompt boost` or simply ask to "boost this prompt," and agent mode will automatically invoke it. The enhanced prompt can then be used to get more accurate and relevant responses from Copilot.

Model Context Protocol (MCP) Servers: Advanced Integration

The Model Context Protocol (MCP) is an open protocol that standardizes how applications provide context to AI models. In VS Code, MCP support enhances agent mode by allowing you to connect to external MCP servers and leverage their specialized tools.

MCP server configuration is managed through the `MCP.json` file in your VS Code folder. This file allows you to define server connections, including necessary API keys and other configuration details.

JSON

{
  "servers": [
    {
      "name": "perplexity",
      "type": "perplexity",
      "command": "perplexity-mcp",
      "arguments": [],
      "inputVariables": [
        {
          "name": "perplexityApiKey",
          "description": "Your Perplexity API key"
        }
      ],
      "properties": {
        "perplexityApiKey": "${perplexityApiKey}"
      }
    }
  ]
}

A key security feature of MCP configuration is the use of input variables for sensitive information like API keys. This approach allows you to avoid hard-coding secrets in your configuration files. When you start an MCP server for the first time, VS Code will prompt for these inputs and store them securely.

Using Perplexity for Research in VS Code

One powerful example of MCP integration is using Perplexity for research directly within VS Code. With a properly configured Perplexity MCP server, you can access Perplexity's research capabilities without leaving your coding environment.

For instance, you could prompt Copilot to "research with Perplexity what the best MCP servers for front-end development are and create a splashy listing page." Agent mode would then automatically invoke the Perplexity research tool, gather the information, and use it to generate and edit code for your new page.

Tool Permissions and Confirmation Settings

When certain tools are invoked in agent mode, Copilot will request confirmation before running them. This is an important security feature, but it can become repetitive for frequently used tools that you trust.

VS Code provides options to automatically confirm specific tools at different levels:

For the current session only
For the current workspace
For all future invocations

These settings can be accessed through the dropdown menu on the continue button when a tool confirmation prompt appears. By configuring these permissions appropriately, you can create a smoother, more efficient workflow while maintaining security.

Best Practices for Using Agent Mode in VS Code

**Start with clear requests**: The more specific your prompt, the better results you'll get from agent mode.
**Use the right tools for the job**: Familiarize yourself with available tools and their capabilities.
**Leverage extension tools**: Install extensions that provide additional tools relevant to your workflow.
**Configure MCP servers**: For specialized tasks, set up appropriate MCP servers to extend Copilot's capabilities.
**Manage tool permissions wisely**: Configure automatic confirmation for trusted tools to streamline your workflow.
**Review tool outputs**: Always review the results of tool invocations before applying changes to your code.

Building Your Own Tools with the Language Model Tool API

For developers looking to extend agent mode with custom functionality, VS Code provides the Language Model Tool API. This API allows you to create extensions that contribute tools to agent mode, tailored to your specific development needs.

By developing custom tools, you can integrate specialized functionality directly into your VS Code environment and make it available to Copilot in agent mode. This opens up endless possibilities for enhancing your development workflow.

Conclusion: Transforming Your Coding Workflow

Agent mode in VS Code represents a significant evolution in how developers interact with AI coding assistants. By combining code editing capabilities with tool invocation, it creates a seamless, productive coding experience that adapts to your needs.

Whether you're using built-in tools, extension-provided capabilities, or connecting to sophisticated MCP servers, agent mode offers a flexible, powerful approach to AI-assisted development. As you incorporate these tools into your workflow, you'll likely discover new ways to enhance your productivity and code quality.

Start exploring agent mode in VS Code today, and experience the future of AI-assisted coding firsthand. The combination of GitHub Copilot's intelligence with the extensibility of VS Code creates a truly transformative development environment.

Unlock the Full Potential of VS Code's Agent Mode: A Developer's Guide to GitHub Copilot Tools