GitHub Copilot agent mode in your IDE: how it works and how to use it

GitHub Copilot agent mode is the chat mode in your IDE where Copilot does the work instead of just suggesting it: you describe a task, and it picks the files to change, edits them across your project and runs terminal commands, iterating until the task is complete. You open Copilot Chat, choose Agent in the mode dropdown and send a prompt.

GitHub's docs put it this way: "In agent mode, Copilot takes a high-level task, decides which files to change, makes the edits, and runs commands as needed, iterating until the task is done." This guide is based on GitHub's agent mode documentation read on 24 October 2026.

What does Copilot agent mode do?

Agent mode turns Copilot Chat from a question and answer tool into an agent that acts on your workspace. For one prompt, it can:

• Find the relevant code in your project.
• Propose and stream edits into the editor, across several files.
• Suggest terminal commands, such as installing a package or running tests, and run them once you confirm.
• Read the results, fix errors it introduced and keep going until the original task is done.

You stay in control throughout. GitHub notes that "you review the changes, and by default you approve commands before they run." Your administrator, or your own editor settings, can allow some commands to run automatically.

GitHub suggests agent mode when your task is complex and involves multiple steps, iterations and error handling, when you want Copilot to work out the steps itself, or when the task needs an external tool such as an MCP server.

Which IDEs support agent mode?

Agent mode is available in five editors. The setup steps differ slightly in each:

If you don't see Agent in the selector, GitHub says "your enterprise or organization administrator may have disabled agent mode for your IDE."

In JetBrains IDEs you have more than one entry point. GitHub's Copilot in IDEs overview lists the GitHub Copilot plugin, Copilot inside JetBrains AI Assistant (through the Agent Client Protocol) and Copilot CLI in the integrated terminal. It recommends the plugin for the full set of IDE features.

How do you use agent mode in VS Code?

VS Code has the deepest agent support, so here is the full flow from GitHub's docs:

1. Open the chat view from the Copilot Chat menu if it isn't already showing.
2. At the bottom of the chat view, make sure Agent is selected in the agents dropdown.
3. Submit a prompt. Copilot streams edits into the editor, updates the working set and runs terminal commands if needed.
4. Review and iterate on the changes, or run a code review on them.

VS Code Copilot Chat has three modes, and you switch between them in the same dropdown:

• Ask answers questions about your code and suggests code without editing files.
• Plan researches the task and drafts an implementation plan before any code changes.
• Agent carries out the task autonomously.

A good prompt names the goal, the constraints and how to check the result. For example:

Add server-side validation to the signup form in src/routes/signup.ts.
Reject emails without a domain and passwords under 12 characters.
Return 400 with a JSON error. Add tests in tests/signup.test.ts and run npm test until they pass.

How do you steer agent mode while it works?

GitHub describes agent mode as interactive. While Copilot is working you can:

• Send a follow-up prompt to redirect it before it finishes.
• Confirm or reject each terminal command it proposes, unless commands have been set to run automatically.
• Review edits as they appear and undo any you don't want.

Read each proposed command before you approve it. Approving a command lets Copilot run it with your local permissions, so treat a destructive command (deleting files, force pushing, dropping a database) the way you would from a teammate: ask why first.

When should you use plan mode first?

For a large or ambiguous task, GitHub recommends drafting a plan first with plan mode. The plan agent researches the task "using read-only tools and codebase analysis," breaks it into steps and lists open questions. It does not change code until you approve.

In VS Code, select Plan in the agents dropdown, describe the task and answer the agent's questions. When the plan is ready you can:

• Click Start Implementation to switch to agent mode and carry out the plan.
• Click Open in Editor to get the plan as Markdown in an editor tab, to work through yourself or save for later.

Plan first, then agent, is a reliable pattern for refactors and new features where a wrong assumption early on would waste a long agent run.

How do you extend agent mode?

Much of what agent mode can do comes from the tools it can call. You can extend it in several ways:

• MCP servers. Model Context Protocol servers add tools for external systems and for GitHub itself. GitHub has a guide to extending Copilot Chat with MCP and to using the GitHub MCP Server in your IDE.
• Custom instructions. Files such as .github/copilot-instructions.md give the agent your coding standards on every request. See the custom instructions guide.
• Agent skills. Folders with a SKILL.md file teach Copilot a repeatable workflow it loads only when relevant. GitHub lists agent mode in VS Code, Visual Studio and JetBrains IDEs among the places skills work. See the Copilot agent skills guide.
• Custom agents. A custom agent is a specialist with its own instructions and tools that you pick from the agent dropdown before you send a task.
• Subagents. In VS Code, enable the runSubagent tool and the main agent can hand a self-contained subtask to a separate agent with its own context window. The result comes back to your main chat.

You can also change the AI model before you send a task. Copilot Free and Copilot Student are limited to auto model selection.

How much does agent mode cost?

GitHub's plans page marks agent mode as included in every plan: Free, Student, Pro, Pro+, Max, Business and Enterprise. Usage is metered, though. GitHub's docs say "each prompt you enter consumes GitHub AI Credits," and the billing docs warn that agentic features "can involve multiple model calls within a single task," so a long agent session on a large codebase uses far more than a quick chat question.

Three habits keep the cost down: pick a lighter model for simple tasks, keep prompts focused on one goal, and use plan mode before a large change so the agent doesn't take a wrong path. For allowances by plan, see the GitHub Copilot pricing guide.

How does agent mode compare with Copilot's other agents?

Copilot now has several agent surfaces, and they suit different jobs:

GitHub's docs also describe managing cloud agent sessions from VS Code, JetBrains IDEs, Eclipse and Visual Studio (JetBrains and Eclipse support is in public preview), so you can start a cloud task without leaving the editor when you don't need to watch it. For a look at how Copilot compares with other agents, see Claude Code vs Copilot and Cursor vs Copilot.

Keep the prompts that work

Agent mode is only as good as the task you hand it, and a prompt that produced a clean change is worth reusing. Kipt keeps your prompts and Agent Skills as Markdown in a private GitHub repo you own, with {{name}} blanks for the parts that change and Cmd+K search, so your best agent mode prompts are a few keystrokes away next time.