GitHub Copilot

GitHub Copilot is GitHub's AI coding assistant, now with an agent mode, a terminal CLI and a cloud agent. It runs in VS Code, Visual Studio, JetBrains, Xcode and more. Plans run from $0 to $100 a month, metered in AI Credits worth one cent each. Checked 31 October 2026.

At a glance

What it is

Copilot began as autocomplete. It is still the product people picture when they hear the name: gray suggestions appear as you type. Over time it grew an agent mode in the editor, a CLI, code review on pull requests, and a cloud agent you can assign issues to.

That makes it the widest agent in this directory by reach, and it shapes who it suits. It is built for people who already live in an editor and on GitHub. If your day is in VS Code or a JetBrains IDE, Copilot is already there.

The plans page lists what is on every plan: editors and IDEs, the CLI and GitHub itself. Agent mode, MCP server integration and custom instructions and agents are included on all plans, Free included.

Plans and prices

Notes that change what you will actually pay:

• "1 AI credit = $0.01 USD." Code completions and next edit suggestions do not use credits. Chat and agent work does.
• Free is capped at 2,000 inline suggestions a month and entry-level models.
• Paid plans have unlimited inline suggestions and can buy extra credits. Free cannot.
• Pooled, organization-wide credits are not offered on any of these four plans.
• Business and Enterprise prices are not on the plans page. Business is $19 per user per month with 1,900 credits, and Enterprise is $39 with 3,900, according to the pricing research on our GitHub Copilot pricing page.

For the breakdown see GitHub Copilot pricing.

What each tier unlocks

The plans page also says none of these four include enterprise-grade security, IP indemnity, user management on github.com, usage metrics or SAML SSO. Those sit in business tiers.

Models

The model list is the same on every plan. It is long, and it changes. On 31 October 2026 the plans page named:

Being on the list does not mean every model is in every plan at the same credit cost. Heavier models burn credits faster.

This breadth is Copilot's clearest edge over single-vendor agents. You can switch from a Claude model to a GPT model in the same editor without changing tools.

Install Copilot CLI

The CLI is the terminal agent. It needs an active Copilot subscription, and an administrator can disable it for an organization.

# npm, all platforms (Node.js 22 or later)
npm install -g @github/copilot

# Homebrew, macOS and Linux
brew install --cask copilot-cli

# WinGet, Windows
winget install GitHub.Copilot

# Install script, macOS and Linux
curl -fsSL https://gh.io/copilot-install | bash

For pinned installs, the script takes VERSION and PREFIX variables, for example VERSION="v0.0.369". On Windows you need PowerShell v6 or higher. Prerelease builds exist for npm, WinGet and Homebrew if you want them.

Sign-in

1. Browser. On first launch, run /login and follow the prompts.
2. Token. Create a fine-grained personal access token under your personal account with the Copilot Requests permission, then export it as COPILOT_GITHUB_TOKEN, GH_TOKEN or GITHUB_TOKEN (checked in that order). The permission is only available on user-owned tokens, not organization ones.

Using it

copilot                                   # interactive
copilot -p "Show me this week's commits and summarize them" --allow-tool='shell(git)'
copilot --cloud                           # session in a GitHub-hosted sandbox

In the interactive session Shift+Tab cycles between modes: ask or execute (the default) and plan, where Copilot builds a plan and asks clarifying questions before writing code. /model or --model changes the model, and /mcp helps you find server names. Models with extended capability offer a one-million-token context and configurable reasoning levels, which use more credits.

You can also bring your own provider through environment variables: COPILOT_PROVIDER_BASE_URL, COPILOT_PROVIDER_TYPE (openai, azure or anthropic), COPILOT_PROVIDER_API_KEY and COPILOT_MODEL. The model has to support tool calling and streaming.

MCP and customization

The docs say MCP servers "allow you to give Copilot access to different data sources and tools." In the CLI you can allow or deny tools per server, for example --deny-tool='My-MCP-Server(tool_name)'. Custom instructions in the CLI now combine instead of using a priority fallback.

Popular first servers are GitHub MCP (which fits naturally), Playwright MCP and Context7. Browse the MCP server list. For instructions, GitHub's docs list three kinds on github.com: a repository-wide .github/copilot-instructions.md, path-specific NAME.instructions.md files under .github/instructions, and agent instructions in one or more AGENTS.md files, where the nearest one wins. A single CLAUDE.md or GEMINI.md in the repository root also works.

Privacy and safety

The CLI doc is clear about what is on you.

• Trusted directories. Do not launch it from your home directory. GitHub "does not guarantee that all files outside trusted directories will be protected."
• Sandbox. /sandbox enable restricts it locally, and copilot --cloud runs it in an isolated cloud sandbox.
• Auto-approval. Flags like --allow-all-tools let Copilot run any command you can run without asking.
• Content exclusion. For Business and Enterprise users, excluded files are not used as context.
• Copilot Memory. It can store repository facts and personal preferences, and may ask you to approve new memories.

Training and retention terms are not on the pages we read.

The three ways Copilot works for you

It helps to separate three modes, because they bill and behave differently.

Inline suggestions. As you type, Copilot offers code. Free allows 2,000 a month; paid plans are unlimited, and these do not use credits. This is the part that costs you nothing extra once you have a paid seat.

Chat and agent mode in the editor. You describe a task, it plans, edits files and runs commands. Agent mode is available in VS Code, Visual Studio, JetBrains, Eclipse and Xcode. This work uses credits, and heavier models use more.

Cloud work on GitHub. On Pro, Pro+ and Max you can assign work to Copilot and start issues from agents, editors or third-party project tools. The cloud route also supports MCP and custom agents. Pull request review is part of this tier too: reviews of pull requests, file diffs in editors, and custom instructions through an instructions.md file.

On Pro+ and Max you can go one step further and delegate to third-party agents such as Claude and OpenAI Codex, listed as preview. That is why Copilot and the vendor agents are not strictly rivals: you can reach them through it.

Questions people ask

Is the Free plan useful? It is a real trial. You get agent mode, MCP, the CLI and 2,000 inline suggestions a month, with entry-level models and limited chat and agent usage. It has no code review, no cloud agent and no extra credits.

What is the "flex allotment"? On each paid plan the total credits are higher than the price, because GitHub adds a flex amount on top: $5 on Pro, $31 on Pro+ and $100 on Max. The plans page says the flex allotments may change over time, so do not plan around them.

Do I need GitHub to use it? You need a GitHub account and a Copilot subscription. The CLI also needs it to be enabled by your organization if you belong to one.

Is there a public code filter? The plans page lists a public code filter with code referencing on all plans.

Can I use my own model provider? In the CLI, yes, through the provider environment variables above, as long as the model supports tool calling and streaming.

Custom instructions, set up properly

Copilot reads more than one kind of instruction file, and choosing the right one matters because they apply in different places. GitHub's documentation describes three types for Copilot on github.com.

When a path-specific file matches the file Copilot is working on and a repository-wide file also exists, both are used. That makes the split natural: put build and test commands and general conventions in the repository-wide file, and put language-specific rules, such as "in *.test.ts, use the project's mock helpers", in path files. Which surfaces honour which type differs, and GitHub keeps a table of clients and surfaces in its concepts page, so check it for the editor you use. The docs also say Copilot cloud agent can generate a first copilot-instructions.md for you from a prompt on the agents tab, which saves an hour on a large repository. Read what it writes, because it records what it saw, including mistakes.

A short repository-wide file that works well:

# Build and test
- Install: npm ci
- Test: npm test -- --run (all tests must pass before a PR)
- Lint: npm run lint

# Conventions
- TypeScript strict; no `any`
- New endpoints need a test in tests/api
- Do not edit generated files in src/gen

Keep it under a page. A long file costs input tokens on every request and gets skimmed by the model, so list only what it cannot work out by reading the code.

Team cost by seat

Business and Enterprise are priced per user, which makes a team estimate simple multiplication. These use the per-seat prices from our pricing page, and ignore tax and any discounts.

The credits column shows why the plans page notes that individual plans have no pooled credits. Business seats come with 1,900 credits each (worth $19), and the extra feature set is what the price difference to Pro buys: organization controls, content exclusion and the other business items named on GitHub's pages. The practical question is how unevenly your developers use agents. If two people use agent mode all day and the other eight rarely, per-seat credits waste money on eight seats and run short on two. Check whether the plan lets you buy extra credits for heavy users before you commit.

How to choose a model without burning credits

Copilot lists over thirty models, and every one is a decision about credits. A pragmatic approach:

1. Default to a mid-size model for routine work. Renames, small refactors and test writing rarely need the heaviest model.
2. Move up for planning and hard debugging. One expensive request that gets the design right costs less than five cheap ones that miss.
3. Keep one model fixed when you compare. If you want to judge Copilot against another agent, use the same model family in both, or you measure the model and not the tool.
4. Watch the usage page weekly. Credits are one cent each, so a bar that is falling faster than the month is a signal to change habits, not to buy more.
5. Remember completions are free of credits. Inline suggestions and next edit suggestions do not draw on your pool, so use them for small edits and save credits for agent work.

Models with a million-token context and configurable reasoning levels use more credits, as the CLI docs say. Turn the reasoning up only when a task has failed at the lower setting.

When Copilot is the wrong tool

Copilot suits people who want an agent inside the editor and GitHub workflow they already use. It is a weaker fit in a few cases.

• You want one scripted, terminal-first agent with hooks, skills and subagents that you control closely. A dedicated CLI agent goes deeper, and our AI coding agents page compares them.
• You must self-host or audit the code. Copilot is a proprietary service.
• You want one flat monthly price with no metering. The credit model means heavy use can run out of pool.
• You work in an editor Copilot does not support. Check the list of editors against your own.

None of these is a flaw. They are reasons to pair Copilot with another tool or pick a different one.

Who it suits

• Developers who want completions as well as an agent, in the editor they use now.
• Teams already on GitHub who want PR review and issue assignment in the same place.
• People in JetBrains, Xcode, Eclipse, Vim or Zed, where a single-vendor terminal agent has no home.
• Anyone who wants to try many models on one subscription.

It is less natural if your whole workflow is a terminal agent with scripts, scheduled runs and subagents. That is where Claude Code is deeper.

Moving to it from another agent

1. Install the extension in your editor, or the CLI above.
2. Bring your rules: copy your project instructions into the file Copilot reads (check the docs for the name).
3. Re-add MCP servers in Copilot's configuration.
4. Pick a model deliberately. If you used Claude elsewhere, choose a Claude model here to keep the comparison fair.
5. Try Pro first. Move to Pro+ only if you need third-party agent delegation or run out of credits.

Alternatives and duos

Our take

This comes from GitHub's plans page and the CLI docs. We have not tested Copilot for this page.

The strongest fact is reach. Eight editor families, a CLI, the web and mobile, and a model list that spans six vendors make it the easiest tool to adopt without changing habits. The cheapest paid plan is $10, half the price of the entry Claude plan, and completions do not use credits at all.

The cost to watch is the credit model. A flat monthly price now buys a pool of dollar-value credits, and heavy agent use on large models can drain it. Pooled credits are not on the individual plans, so a team has to plan seat by seat.

If you write code by hand and want an agent when you ask for one, start with Pro. If the agent is your main interface, compare it with Claude Code on one real task.

Checklist

• Pick a plan and note its credit pool
• Install the editor extension or @github/copilot
• Do not launch the CLI from your home directory
• Add one MCP server and review its tools
• Choose a model and watch how fast credits fall
• Check data terms for your plan before using work code