GitHub Copilot CLI: the coding agent GitHub ships to your terminal

Five ways to install the same binary

The repository is tiny. The tracked files are `LICENSE.md`, `README.md`, `changelog.md`, `install.sh` and a `.github/` directory, with the language recorded as Shell. Everything you run comes from a downloaded artifact rather than from building a source tree, which is the first thing to know about this project.

For macOS and Linux the install script is the documented path:

curl -fsSL https://gh.io/copilot-install | bash

The script reads two environment variables that the README explains. `VERSION` pins a specific build, and `PREFIX` decides the install directory, defaulting to `/usr/local` when you run as root and `$HOME/.local` otherwise. Piping to `sudo bash` installs to `/usr/local/bin`. A pinned version into a custom directory looks like this:

curl -fsSL https://gh.io/copilot-install | VERSION="v0.0.369" PREFIX="$HOME/custom" bash

The package managers cover the rest. Homebrew installs `copilot-cli` on macOS and Linux, with a `copilot-cli@prerelease` formula for the beta channel. WinGet installs `GitHub.Copilot` on Windows. npm installs `@github/copilot` globally, and that path is the only one the README says works on all three platforms at once, so it is the sensible choice for a machine where you would rather not run a shell installer.

Windows also carries a prerequisite that is easy to miss: PowerShell v6 or higher. The README lists Linux, macOS and Windows as supported platforms and puts the PowerShell requirement in parentheses against Windows only.

Authentication decides what the agent can reach

On first launch, if you are not already logged in to GitHub, the CLI prompts you to run the `/login` slash command and follow the on-screen instructions. That path uses your existing GitHub session, which is the reason the tool can talk about your issues and pull requests without extra setup.

There is a second route for headless machines: a fine-grained personal access token with the `Copilot Requests` permission. The README walks through creating one at the personal access tokens page, adding that single permission under `Permissions`, then exposing it through `GH_TOKEN` or `GITHUB_TOKEN`, in that order of precedence. One permission for the whole tool is a reasonable scope, and it is what you would want in CI where there is no browser to complete an interactive login.

The third gate is organizational, and it is the one that catches people out. If you reach Copilot through an organization or enterprise, your owner or administrator can disable Copilot CLI in the organization settings, and the README says plainly that you cannot use the tool if they have. There is no local workaround for that, and it is worth checking before spending time on the install.

The cost sits in the same place. Each prompt you submit reduces your monthly quota of premium requests by one, and the README links to the page explaining what counts as a premium request.

Model choice defaults to Claude, not to GitHub's own

This is the detail that tells you what the tool is. By default `copilot` runs on Claude Sonnet 4.5, and the `/model` slash command switches to other available models, which the README names as Claude Sonnet 4 and GPT-5. GitHub is distributing an agent whose default underlying model is Anthropic's, with OpenAI's as an alternative.

The consequence for evaluation is straightforward. Choosing between Copilot CLI and another terminal agent is not only a choice of harness; it is also a choice of which models you can reach from inside it, and Copilot CLI's model list is short and named in the documentation rather than open-ended. If your work depends on a particular model being reachable, that list is the thing to check.

The harness itself is described as the same agentic harness behind GitHub's Copilot coding agent, with the CLI presenting it synchronously and locally instead of as a background job on a server. The README's own framing is that the project is early: it asks for feedback and describes rapid iteration, which is consistent with three releases in five days in the tag list.

Approval before action, and experimental mode for autopilot

The stated control model is that every action is previewed before execution and nothing happens without explicit approval. That is the design decision most worth checking against your own risk tolerance, since it means the agent can read your repository, run commands and wait for you at each step.

Experimental mode is where the agent stops waiting as often. It is enabled either by launching with `copilot --experimental` or by running the `/experimental` slash command from inside a session, and the setting persists in your config afterwards, so the flag is a one-time thing. The headline feature in that mode is autopilot, which you enter by pressing `Shift+Tab` to cycle through modes and which encourages the agent to keep working until a task is finished.

The release notes show this being tightened rather than loosened. v1.0.86 changed autopilot so it stops after an accepted task completes instead of continuing, and the same release fixed the status row to say it is waiting for background shells, rather than `Working`, when a turn ends while an attached background process such as a dev server is still running. That is a small fix with a real meaning: the tool has learned to distinguish an agent that stopped from an agent that is blocked.

LSP support that requires you to bring the server

The CLI supports the Language Server Protocol for go-to-definition, hover information and diagnostics, and it deliberately does not bundle any servers. You install the one your language needs, with TypeScript given as the example:

npm install -g typescript-language-server

Configuration then goes in one of two places. A user-level file at `~/.copilot/lsp-config.json` applies to every project, and a repository-level `.github/lsp.json` applies to that repository only. The README shows an example JSON object with a `lspServers` key mapping a language name to a `command`.

The repository-level option is the interesting one for teams. Committing `.github/lsp.json` means everyone working on the repository gets the same language intelligence without installing a personal config, which is a smaller ask than agreeing on shell profiles or editor settings.

What the changelog reveals about the agent plumbing

`changelog.md` sits in the repository root and the three most recent releases tell you more about how the tool behaves than the README does. v1.0.87, published 2026-09-21, and v1.0.87-0 three days earlier, both add a `worktreePathTemplate` setting that decides where `/worktree`, `/move`, `/new` and `--worktree` create git worktrees. Unset, it keeps the current layout of `<repo>.worktrees/` with slashes in branch names flattened to dashes. Set, you can use placeholders like `{repo}`, `{branch}` and `{branchSlug}`, for example `~/src/worktrees/{repo}/{branch}`.

That is a GitHub-native answer to the problem every terminal coding agent has, and it is the clearest signal in the release notes that this tool is being built for parallel agent work rather than one session at a time.

Two more entries are worth naming. The same release reworked how steering prompts queue: consecutive prompts in the same mode combine into one pending message you can recall with `Up`, `Ctrl+C` stops the running turn instead of deleting pending prompts one at a time, `Ctrl+Q` keeps queued prompts separate, and `Ctrl+P` browses history without withdrawing prompts. v1.0.87 also fixed sandbox proxies on Windows and made proxies with a username and password work on every platform, and v1.0.87-0 added a per-server MCP setting called `slowConnectionThresholdMs` for warning thresholds, plus live elapsed time for execution subagents in the timeline.

One more detail says something about how the tool treats its own instructions. v1.0.86 lets custom agents opt into repository instruction files, naming `AGENTS.md`, `copilot-instructions.md` and `CLAUDE.md`, by setting `include-custom-instructions: true` in their frontmatter. The CLI reads the same convention other coding agents use, which makes an existing repository setup portable rather than exclusive.

Editorial conclusion

Copilot CLI is a good fit for someone already inside the GitHub ecosystem who wants agentic edits in a terminal without giving up review control, and a poor fit if your organization has not enabled it or if you want a tool you can read and build on. The concrete starting point is the install script followed by `/login`, then a look at `--experimental` for autopilot and at `.github/lsp.json` if you want go-to-definition in a language the CLI does not bundle a server for. Expect the quota line in the README, one premium request per prompt, to be the first thing you check when the tool starts costing you.

Frequently asked questions

Official sources

1. github/copilot-cli on GitHub
2. Issues
3. README
4. Releases