# GitHub Copilot CLI vs Claude Code: how to choose in 2026

URL: https://agentvera.dev/en/blog/copilot-cli-vs-claude-code/ · Published: 2026-10-24

GitHub Copilot CLI vs Claude Code: plans and pricing, models, effort levels, permissions and sandbox, resume, MCP and install, plus running both in AgentVera.

**In short:**

- Copilot CLI needs a GitHub Copilot subscription and offers models from several vendors, Claude among them; Claude Code needs a Claude plan or API account and runs Claude models.
- Both CLIs take an effort level up to max, resume sessions with --resume and read CLAUDE.md, so one repo can serve both.
- Copilot CLI ships a built-in GitHub MCP server and an autopilot mode; Claude Code adds permission modes, hooks, skills and subagents.

**GitHub Copilot CLI vs Claude Code is a choice between a multi-vendor agent tied to your GitHub plan and a Claude-only agent with deeper controls.** Copilot CLI is GitHub’s terminal agent: you sign in with GitHub, it uses your Copilot subscription and lets you pick models from several vendors, Claude included. Claude Code is Anthropic’s: you sign in with a Claude plan or an API account, it runs Claude models and adds permission modes, hooks, skills and subagents around them. Both take an effort level, resume sessions with `--resume`, connect to MCP servers and read `CLAUDE.md`.

This post compares sign-in and pricing, models, effort, permissions and sandboxing, session resume, MCP and install, then shows how to run both side by side. No benchmark scores; with Copilot you can run the same Claude model in both, so the difference is mostly the tool around it.

## Copilot CLI and Claude Code at a glance

| | GitHub Copilot CLI | Claude Code |
| --- | --- | --- |
| Maker | GitHub | Anthropic |
| Command | `copilot` | `claude` |
| Sign in | GitHub account (`copilot login`, `/login`) | Claude account or Console (API) account |
| Plan needed | Active Copilot subscription | Pro, Max, Team, Enterprise or Console |
| Models | Several vendors (Anthropic, OpenAI, Google and more), `auto` | Claude models (`sonnet`, `opus`, `haiku` aliases) |
| Effort | `--effort` low, medium, high, xhigh, max | `--effort` low, medium, high, xhigh, max (depends on model) |
| Modes | interactive, plan, autopilot | default, acceptEdits, plan, auto, dontAsk, bypassPermissions |
| Tool rules | `--allow-tool`, `--deny-tool`, `/permissions` | Permission rules, hooks |
| Sandbox | `/sandbox enable` | Built-in sandboxing (macOS, Linux, WSL2) |
| Resume | `--resume`, `--continue`, `/resume` | `-c`, `-r`, `--fork-session` |
| Instructions | Merges `CLAUDE.md`, `AGENTS.md`, `.github/copilot-instructions.md` and more | `CLAUDE.md` |
| MCP | Built-in GitHub MCP server, `~/.copilot/mcp-config.json`, `.mcp.json` | `claude mcp`, `.mcp.json` |

## Sign-in and pricing

### Copilot CLI

Copilot CLI signs in with your GitHub account through `copilot login` or `/login` in a session, and it needs an active Copilot subscription. If you are on a company plan, an admin can turn the CLI off for the organization.

At the time of writing (October 2026), GitHub lists Copilot Free ($0, limited usage), Pro ($10/month), Pro+ ($39/month), Max ($100/month), and Business and Enterprise for organizations. Usage is billed in GitHub AI Credits, and the CLI draws on them; paid personal plans can buy extra credits. Check the current details on [GitHub’s Copilot plans page](https://github.com/features/copilot/plans "GitHub Copilot plans").

### Claude Code

Claude Code needs a Claude Pro, Max, Team or Enterprise plan or a Console (API) account; the free Claude plan does not include it. It can also run through Amazon Bedrock, Google Cloud and Microsoft Foundry.

At the time of writing (October 2026), Anthropic lists Pro at $17/month billed annually or $20 monthly, Max from $100/month, and Team standard seats at $20 per seat per month billed annually or $25 monthly. Usage limits reset in 5-hour windows with a weekly cap; see [Claude Code usage limits](/en/blog/claude-code-usage-limits/ "Claude Code usage limits"). Current prices are on [Anthropic’s pricing page](https://claude.com/pricing "Claude pricing").

## Models and effort

Copilot’s big draw is choice. `--model` (or `/model` inside a session) picks a model from Anthropic, OpenAI, Google and other vendors, and `auto` lets Copilot choose. `--effort` (also `--reasoning-effort`) takes low, medium, high, xhigh or max.

Claude Code runs Claude models only. `--model` takes aliases such as `sonnet`, `opus` and `haiku` or a full model name, and `--effort` takes low, medium, high, xhigh or max, depending on what the model supports. If you only want Claude models, Claude Code gives you the most features around them; if you want to switch vendors per task, Copilot does that in one tool.

## Permissions, modes and sandbox

### Copilot CLI

- **Modes:** `--mode interactive`, `plan` or `autopilot`; `--plan`, `/plan` and `/autopilot` switch too, and Shift+Tab cycles through them. Autopilot keeps working without stopping for each step.
- **Tool rules:** `--allow-tool` and `--deny-tool` allow or block specific tools, and a deny always wins. `--allow-all-tools` approves every tool; `--allow-all` (or `--yolo`) approves everything.
- **Presets:** `/permissions default`, `assisted` or `allow-all` change the level in a running session.
- **Sandbox:** `/sandbox enable` turns on a local sandbox that restricts file system and network access.
- **Trusted directories:** Copilot asks before it works in a folder you haven’t trusted.

### Claude Code

- **Permission modes:** `--permission-mode` takes `default` (asks), `acceptEdits`, `plan`, `auto`, `dontAsk` or `bypassPermissions`. `--dangerously-skip-permissions` skips every prompt.
- **Rules and hooks:** allow and deny rules in settings, plus [hooks](/en/blog/claude-code-hooks-guide/ "Claude Code hooks guide") that run your own scripts before or after tool calls.
- **Sandbox:** built-in sandboxing on macOS, Linux and WSL2; not on native Windows.

Skipping all prompts is risky in both. Keep that for an isolated folder or container; [AI coding agent security](/en/blog/ai-coding-agent-security/ "AI coding agent security") covers why.

## Session resume

- **Copilot CLI:** `copilot --resume` opens a picker, `--resume=ID` or a session name picks one, `--continue` takes the latest, and `/resume` works inside a session. `-n` names a session and `--session-id` sets its ID.
- **Claude Code:** `claude -c` continues the latest session in the folder, `claude -r` resumes by ID or name, `--session-id` sets the ID and `--fork-session` starts a new branch from a resumed session.

Both have `/compact` to shrink a long conversation.

## Instructions and MCP

Here the two fit together unusually well. Copilot CLI merges custom instructions from **`CLAUDE.md`**, `GEMINI.md`, `AGENTS.md`, `.github/copilot-instructions.md`, `.github/instructions/**/*.instructions.md` and `.claude/rules/**/*.md`. A repo already set up for Claude Code gives Copilot its rules without extra work.

For [MCP](/en/blog/what-is-mcp-server/ "What is an MCP server?"), Copilot CLI ships with a built-in GitHub MCP server, so issues, pull requests and repos are there from the start (`--disable-builtin-mcps` turns it off). You add servers with `/mcp add` or `copilot mcp`, they live in `~/.copilot/mcp-config.json`, and Copilot also reads a repo’s `.mcp.json`. Claude Code manages servers with `claude mcp` and uses the same `.mcp.json` for project-scoped servers, so one file can serve both.

## Install

```bash
# GitHub Copilot CLI
npm install -g @github/copilot          # Node 22+
brew install --cask copilot-cli
winget install GitHub.Copilot
curl -fsSL https://gh.io/copilot-install | bash

# Claude Code
curl -fsSL https://claude.ai/install.sh | bash
brew install --cask claude-code
winget install Anthropic.ClaudeCode
```

On Windows, Claude Code also installs from PowerShell with `irm https://claude.ai/install.ps1 | iex`.

## Strengths, honestly

**Copilot CLI** is strongest when your team lives on GitHub and already pays for Copilot: one bill, models from several vendors, the GitHub MCP server built in, and handy commands such as `/review`, `/delegate` and `/fleet`. Autopilot mode and allow and deny tool rules make it easy to set how much it does on its own.

**Claude Code** is strongest when you want the deepest control over a Claude model: six permission modes, hooks, skills, [subagents](/en/blog/claude-code-subagents/ "Claude Code subagents"), session forking and a large ecosystem built around `CLAUDE.md`. Its limit is that it is Claude only and needs a Claude plan or API account.

## Copilot CLI and Claude Code in AgentVera

AgentVera is a desktop app for macOS, Windows and Linux that runs 18 terminal coding agent CLIs side by side in real terminals, in a grid per project, with your existing logins. [GitHub Copilot CLI](/en/agents/copilot-cli/ "GitHub Copilot CLI in AgentVera") and [Claude Code](/en/agents/claude-code/ "Claude Code in AgentVera") are both in the New agent dialog.

| Need | In AgentVera |
| --- | --- |
| Sign in | Copilot uses its own GitHub login; if you are signed out, run `/login` in its terminal. Claude Code uses your existing login, and each added account gets its own `CLAUDE_CONFIG_DIR` |
| Pick a model | Copilot: leave it empty for the default or pick one, passed with `--model`. Claude Code: models from its local catalog, plus Fast mode |
| Effort | Copilot: minimal to max, passed with `--reasoning-effort`. Claude Code: Auto, low to max on a slider |
| Role and instructions | Copilot: added as an extra instructions folder (`AGENTS.md`), your own instructions stay. Claude Code: `--append-system-prompt` |
| Permissions | Ask, Auto or Full access per agent, limited to the levels each CLI supports |
| Keep sessions | Both start with their own `--session-id` and reopen with `--resume`; Claude Code can also fork with `--fork-session` |
| Shared tools | AgentVera’s [MCP servers](/en/features/mcp-manager/ "MCP manager") attach on every launch; for Copilot with `--additional-mcp-config` |
| Check the work | [Automatic code review](/en/features/code-review/ "Automatic code review") at the end of each turn |
| Chain agents | [Flows](/en/features/flows/ "Flows"): either one can be a source or a target (Pro and Team) |

Automatic code review is a natural fit for this pair. When a turn ends, the Claude model you choose reviews the commits from that turn or all changes, and lists findings by severity with file and line. If you turn it on, the findings go back to the agent for up to two rounds of fixes. So Copilot can write with whichever model you picked and a Claude model checks the result.

With a flow you can go further: when Copilot finishes its turn, its last reply goes into your template (`{{output}}`, `{{source}}`, `{{target}}`) and is sent to Claude Code, which waits its turn if busy. A turn limit stops the loop, and a Human approval node can pause for you, also on Telegram. Copilot also works in broadcasts and scheduled tasks and supports `/compact`.

Claude Code gets the extras that only some CLIs support: [account switching](/en/features/account-switching/ "Account switching") with account chains that move on when the 5-hour or weekly limit runs out (Pro and Team), context profiles, automatic `/compact`, Remote Control and running in Docker. Account switching is not available for Copilot.

### A simple setup

1. Keep your rules in `CLAUDE.md` (or `AGENTS.md` imported from it); Copilot reads both.
2. Open a Copilot CLI agent and a Claude Code agent in the same project, each in its own [git worktree](/en/blog/git-worktree-parallel-agents/ "Git worktrees for parallel agents").
3. Register your MCP servers once in AgentVera so both get them.
4. Turn on automatic code review in project settings.
5. On Pro or Team, add a flow from one agent to the other with a review prompt and a turn limit.

The grid, worktrees, code review and the MCP manager are on the free plan. [Download AgentVera](/en/download/ "Download AgentVera") and try both on your own repo. For more pairs, see [Claude Code vs Codex](/en/blog/claude-code-vs-codex/ "Claude Code vs Codex") and [the best AI coding CLI tools](/en/blog/best-ai-coding-cli-tools/ "Best AI coding CLI tools").

## Which to choose

Pick **Copilot CLI** if you already pay for GitHub Copilot, want to switch between models from several vendors and like having GitHub built in. Pick **Claude Code** if you work mostly with Claude models and want permission modes, hooks, skills and subagents. Since Copilot reads `CLAUDE.md`, trying both on the same repo costs you almost no setup.

## Frequently asked questions

**Do I need a paid plan for Copilot CLI or Claude Code?** Copilot CLI needs an active GitHub Copilot subscription; at the time of writing (October 2026) GitHub lists Free, Pro, Pro+ and Max plans plus Business and Enterprise, billed in GitHub AI Credits. Claude Code is not included in the free Claude plan; it needs Pro, Max, Team, Enterprise or a Console (API) account.

**Can Copilot CLI use Claude models?** Yes. Copilot offers models from several vendors, including Anthropic, OpenAI and Google, and you pick one with `--model` or `/model`. Claude Code runs only Claude models, but gives you the full Claude Code feature set around them.

**Does Copilot CLI read CLAUDE.md?** Yes. Copilot CLI merges custom instructions from `CLAUDE.md`, `GEMINI.md`, `AGENTS.md`, `.github/copilot-instructions.md` and `.github/instructions/**/*.instructions.md`, among others. So a repo set up for Claude Code already gives Copilot CLI its rules.

**How do I resume a session in each?** Both use `--resume`. In Copilot CLI, `copilot --resume` opens a picker, `--resume=ID` or a session name picks one and `--continue` takes the latest. In Claude Code, `claude -c` continues the latest session, `claude -r` resumes one by ID or name, and `--fork-session` branches it.

**Can I run Copilot CLI and Claude Code side by side?** Yes. In AgentVera each agent runs in its own real terminal in a per-project grid with its own login, ideally in its own git worktree. Automatic code review checks each turn, and a flow can pass one agent’s last reply to the other (flows are on Pro and Team).

---

**About AgentVera.** AgentVera is a desktop app for macOS, Windows and Linux, built by Solviera Teknoloji. It runs 18 AI coding agents (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) side by side, per project, in real terminals with the user's own CLI installs and logins. The free plan has unlimited agents. Download: https://agentvera.dev/en/download/ · Pricing: https://agentvera.dev/en/pricing/