GitHub Copilot CLI Goes Generally Available - Autopilot, Multi-Model, and Fleet Mode

GitHub Copilot CLI - the terminal-native coding agent that has been in public preview since September 2025 - hit general availability on February 25, 2026. Every paid Copilot subscriber can now install it, authenticate, and start running agentic coding sessions directly from their terminal. After hundreds of updates during the preview period, this is no longer an experiment. It's GitHub's bet that the terminal is the next major surface for AI-assisted development.

Installation and Setup

Getting Copilot CLI running takes about two minutes. It ships through every major package manager, plus a standalone install script.

# Homebrew (macOS / Linux) - auto-updates
brew install copilot-cli

# npm (all platforms) - requires Node.js 22+
npm install -g @github/copilot

# WinGet (Windows) - auto-updates
winget install GitHub.Copilot

# Shell script (macOS / Linux)
curl -fsSL https://gh.io/copilot-install | bash

After installation, launch with copilot and authenticate via /login. If you prefer non-interactive setups - CI pipelines, remote servers - generate a fine-grained personal access token with the "Copilot Requests" permission and export it as GITHUB_TOKEN.

Platform Compatibility

The tool also ships in the default GitHub Codespaces image, so if your team already uses Codespaces, it is there waiting.

Autopilot Mode

The headline feature at GA is autopilot mode. Press Shift+Tab during an interactive session to cycle through modes until the status bar reads "autopilot," then enter your prompt. Copilot CLI will plan, execute, test, and iterate without stopping for approval at each step.

# Launch and switch to autopilot
copilot

# Or start directly in autopilot from the command line
copilot --autopilot "Add unit tests for the auth module and fix any failures"

When you first enter autopilot, the CLI asks about permissions. Granting full permissions is recommended - if you select limited permissions, the agent will silently skip any tool call that requires elevated access, and you may end up with an incomplete result. You can toggle permissions mid-session with /allow-all.

Safety Controls

Autopilot isn't a runaway process. The --max-autopilot-continues flag caps the number of autonomous steps, and pressing Ctrl+C stops execution right away. The CLI also displays premium request consumption in real time - something like "Continuing autonomously (3 premium requests)" - so you can see exactly what each continuation costs before it runs.

The best workflow is to start in plan mode (Shift+Tab to "plan"), let Copilot build a structured implementation plan, review it, and then accept with "Accept plan and build on autopilot." This gives you human oversight on the architecture while letting the agent handle the repetitive execution.

Multi-Model Support

Copilot CLI isn't locked to a single provider. The /model command lets you switch models mid-session, and the GA release supports the current frontier from all three major labs.

Available Models

The model you choose affects your premium request budget. On the Pro plan, you get 300 premium requests per month. Claude Opus 4.6 carries a 3x multiplier, so each session costs three requests. Sonnet and GPT-5.3-Codex cost 1x. Haiku comes in at 0.33x. Overages are billed at $0.04 per premium request.

This is the same multi-model roster now available across the broader Copilot platform, but having it in the terminal means you can pick a model based on the task without leaving your shell session.

Fleet Mode and Background Delegation

Two features push Copilot CLI beyond a standard chat-in-a-terminal.

Fleet Mode

The /fleet command takes an implementation plan and breaks it into independent tasks, then spins up parallel subagents to execute them concurrently. If you have a plan that involves updating three separate modules, fleet mode can assign each to a subagent and merge the results. You retain full control over what gets applied.

Background Delegation

Prefix any prompt with & and Copilot CLI delegates the work to a cloud-based agent session, freeing your local terminal immediately. Use /resume to check progress or pull the result back into your local session. This is particularly useful for long-running tasks - test suite fixes, large refactors - where you do not want to block your terminal for twenty minutes.

Extensibility

MCP Servers

GitHub's own MCP (Model Context Protocol) server comes built in, giving the agent native access to repositories, issues, pull requests, and workflows through natural language. You can also connect custom MCP servers for internal tools or databases.

Hooks and Plugins

The CLI supports preToolUse and postToolUse hooks for lifecycle integration - useful for enforcing organizational policies or triggering notifications. Plugins can be installed via /plugin install owner/repo, and agent behavior can be customized through markdown-based agent skills files.

Repository Memory

Copilot CLI remembers codebase conventions and patterns across sessions. It learns your project's architecture, coding style, and testing patterns over time, plus maintains cross-session memory so you can reference past work and previous pull requests.

Where It Falls Short

No teardown is honest without the rough edges, and Copilot CLI has several.

Premium request limits bite quickly. The 300 monthly premium requests on the Pro plan sound reasonable until you factor in model multipliers and the reality that autopilot mode burns through requests faster than interactive use. A few complex autopilot sessions with Opus 4.6 can consume a week's budget in an afternoon. Pro+ subscribers get 1,500 requests, but that tier costs $39/month - the same price as an Enterprise seat.

Requires constant internet. Every interaction goes through GitHub's cloud infrastructure. There's no offline mode, no local model fallback. If you work on planes, in restricted networks, or anywhere with unreliable connectivity, this is a non-starter.

Context window is mediated. Unlike using Claude or GPT directly through their APIs - where you get the full context window and feature set - Copilot CLI mediates all interactions through its own Agent Control Plane. For most work this is fine, but developers who need Claude Code's full 200K token context or its native subagent architecture may find the direct tool more capable for complex tasks.

Autopilot is not magic. GitHub's own documentation warns that autopilot works best for "well-defined tasks like writing tests, refactoring files, or fixing CI failures." Vague prompts, open-ended exploration, and tasks requiring nuanced judgment still produce mediocre results. Plan mode helps, but it does not remove the problem.

Cold starts and latency. Some users during the preview period reported noticeable startup times, particularly in cloud-delegated sessions. GitHub has been improving this, but the feedback suggests the experience is not yet as instant as launching other CLI coding tools.

The Competitive Landscape

Copilot CLI enters a crowded terminal-agent market. Claude Code has established itself as the power user's choice for complex multi-file refactoring. OpenAI's Codex CLI offers deep API integration. Gemini CLI brings Google's million-token context window. For a full breakdown, see our comparison of the best AI coding CLI tools.

What Copilot CLI has that none of them match is native GitHub integration. Your repositories, issues, PRs, Actions workflows, and Codespaces are all accessible through natural language without any configuration. If your development workflow already lives on GitHub - and for most teams, it does - that integration eliminates real friction.

GitHub Copilot CLI going GA marks the terminal as an official front in the AI coding assistant war. The multi-model support, autopilot execution, and fleet parallelism make it a capable tool for developers who prefer the command line. The premium request economics and internet dependency are real constraints, but for teams already embedded in the GitHub ecosystem, the path of least resistance just got shorter. Whether it can hold ground against purpose-built competitors like Claude Code and Codex CLI depends on how fast GitHub can close the gap on raw capability - and how much that native platform integration is worth to working engineers.