Last updated: May 2026
GitHub Copilot used to be an autocomplete tool. In 2026 it is two different things depending on what you need: agent mode, which works synchronously inside your IDE, and the coding agent, which works asynchronously in the cloud and delivers a pull request while you do something else entirely.
Most developers have heard of one but not both. This guide covers the coding agent specifically — what it is, how it differs from agent mode, how to configure it, and how to prompt it so it stops producing PRs you have to rewrite from scratch.
The naming causes real confusion, so this needs to be cleared up first.
Agent mode is the synchronous collaborator inside VS Code, JetBrains, and Visual Studio. You open Copilot Chat, select "Agent" from the mode dropdown, and Copilot works in real time alongside you — editing files, running terminal commands, fixing test failures, iterating until the task is done. You watch it work. You stay in the loop.
Coding agent (also called the cloud agent) is asynchronous. It runs inside a GitHub Actions-powered environment. You assign it a GitHub issue — or kick off a task from the Agents panel on GitHub.com — and it works independently in the background. By the time you come back, there is a pull request waiting with code, tests, and a self-review already done.
The practical decision rule: use agent mode when you are actively building and want to steer the process. Use the coding agent when you have a well-scoped task — a bug fix, adding unit tests, a small refactor — that you want handled without occupying your attention.
Both consume premium requests. The coding agent also consumes GitHub Actions minutes.
When you assign a task, the coding agent:
Three capabilities that shipped recently are worth knowing specifically:
Model picker. The Agents panel now lets you choose which model handles each background task. Use a faster model for routine work like adding docstrings. Switch to a more capable model for complex refactors. Set it to auto if you do not want to think about it.
Self-review. Before opening the PR, the agent reviews its own diff using Copilot code review. This catches obvious logic errors and stylistic issues that made early agent output unpleasant to review.
CLI handoff. Press & in the Copilot CLI to hand a task off from the terminal to the cloud agent. The task continues asynchronously while you keep working locally.
| Feature | Free | Pro | Pro+ | Business | Enterprise |
|---|---|---|---|---|---|
| Agent mode (VS Code) | 50/mo | ✓ | ✓ | ✓ | ✓ |
| Coding agent (cloud) | ✗ | ✓ | ✓ | ✓ | ✓ |
| Model picker | ✗ | ✓ | ✓ | Coming | Coming |
| Custom agents | ✗ | ✗ | ✓ | ✓ | ✓ |
The coding agent requires Pro or higher. The free plan only covers agent mode with a 50 interaction/month cap.
The coding agent works in all GitHub-hosted repositories except those owned by managed user accounts or explicitly disabled by an org admin. If your organization has turned it off, an admin can re-enable it under Settings → Copilot → Policies.
The coding agent reads several instruction file formats before starting work. Two you should configure immediately:
.github/copilot-instructions.md — always-on project context. Architecture notes, coding standards, frameworks, how to build and test. The agent reads this before every task. Keep it under 1,000 words — more than that and the effective parts get buried.
AGENTS.md — agent-specific workflow instructions. Which test commands to run, what a successful build looks like, what done means for a task. Place it in the root of your repository. You can nest AGENTS.md files in subdirectories so different parts of a monorepo get different instructions.
Example AGENTS.md for a TypeScript project:
## Build
- Run `npm run build` to compile
- Fix all TypeScript errors before marking a task complete
## Testing
- Run `npm test` after every change
- All existing tests must pass
- Write tests for any new function with external dependencies
## Code standards
- Use async/await, not .then() chains
- Handle all promise rejections explicitly
- Do not use `any` types
## Definition of done
- Build passes
- All tests pass (`npm test`)
- Lint passes (`npm run lint`)
The coding agent also reads CLAUDE.md and GEMINI.md if present — a file you already maintain for another agent works here too.
From GitHub Issues, set the assignee to Copilot. The coding agent picks it up, reads the description, and starts working.
You can also trigger it from:
@github with a task descriptiongh copilot suggest, then & to hand off to the cloudThe quality of the coding agent's output is almost entirely determined by the quality of the input. Vague issues produce PRs that need rewriting. Specific issues produce PRs that need only a quick review.
GitHub's internal framework for effective agent issues is WRAP:
An issue that follows WRAP vs one that does not:
Before:
Fix the login bug
After:
What: Users are being logged out on every page refresh. The session token is not being persisted to localStorage after login.
References: Authentication logic is in
src/auth/session.ts. The login handler ishandleLogin()insrc/pages/Login.tsx. See PR #142 for how we handled a similar persistence issue.Acceptance criteria: After logging in, a page refresh should keep the user logged in. The existing tests in
src/__tests__/auth.test.tsmust all pass. Add a test that verifies session persistence across a simulated page reload.Precautions: Do not use cookies — we use localStorage for all client-side persistence. Do not modify the token format.
Specify the stop condition explicitly. Add something like: "Stop when npm test and npm run lint both exit with code 0." Without a clear stop condition, the agent decides for itself — and it may stop too early or loop on an edge case.
Reference specific files. "Fix the bug in authentication" forces the agent to search. "Fix the token expiry bug in src/auth/session.ts around line 87" gets it there immediately and reduces unintended changes elsewhere.
Separate research from implementation. If you need the agent to first understand a codebase and then implement something, split these into two separate issues. A single issue asking for exploration and implementation tends to produce unfocused output.
Give it failing tests. If you have a test that demonstrates the bug you want fixed, include it in the issue. The agent uses it as a concrete stop condition and produces more targeted fixes.
When the PR is ready, check the Agents panel on GitHub.com for a summary of what happened. When reviewing the PR itself:
@copilot in a PR comment to ask it to revise specific parts — the coding agent reads PR comments and can open a follow-up commitOn Pro+ and higher plans, you can create custom agents — specialized versions of the coding agent with specific tools, instructions, and MCP server access. A custom agent for security reviews has different tools and instructions than one for adding unit tests.
Custom agents are defined in the Agents panel on GitHub.com. You give each one a name, a system prompt, and a set of tools it can access. Team members can then assign issues directly to a named custom agent.
Most useful when you have workflows that recur frequently: a "test-writer" agent with instructions focused on your test framework, a "dependency-updater" agent with instructions about how to handle breaking changes.
Agent mode and the coding agent both draw from your premium request quota. The coding agent uses more per task because it iterates — planning, implementing, testing, and reviewing all count as separate requests.
Monitor your consumption at github.com/settings/copilot. After exhausting the monthly allocation, additional requests cost $0.04 each. Complex tasks — large refactors, multi-file features with integration tests — can consume 10–30 premium requests each.
Practical rule: use the coding agent for well-scoped backlog tasks. Do not assign it an open-ended issue like "improve performance across the codebase" — it will run until it runs out of instructions or requests.
The coding agent occupies a different position compared to Cursor, Windsurf, or Cline. Those tools are in-editor, synchronous, and focused on what you are building right now. The coding agent is cloud-native and asynchronous, designed for work you want to delegate while you focus elsewhere.
The tools are complementary. Use Cursor or Copilot agent mode when you are actively coding. Use the coding agent to process the backlog of smaller issues — test gaps, cleanup tasks, documentation updates — that stay on the backlog because they're important but not urgent enough to occupy your time.
For teams already on GitHub Issues and GitHub Projects, the native integration is a real advantage: an issue you would have assigned to a junior developer can now be assigned to Copilot with the same workflow.