Plan Mode That Turns Ambiguous Tasks Into Structured Work

Plan mode lets developers outline work before execution, using the /plan command to break a task into steps the agent can then carry forward. This matters because agentic tools fail most often when the task is underspecified, and a planning step forces that clarity upfront. Teams can also switch models with /model to compare approaches before committing.

Business outcome: fewer wasted agent runs on misunderstood tasks, and a reviewable plan before any code is written.

Fleet Execution Across Parallelised Subagents

The /fleet capability executes work across parallelised subagents, and can run multiple models at once. For larger tasks this compresses wall-clock time considerably compared with a single sequential agent loop. It also lets teams compare model outputs on the same problem without manual re-prompting.

Business outcome: faster completion of large, decomposable tasks and a practical way to benchmark models on real work.

Resume and Memory That Survive Long Agent Runs

The /resume command returns to long-running work, while memory and compaction keep sessions from collapsing under their own history. This is a direct answer to one of the most common complaints about agentic tools: losing context partway through a multi-hour task. Smoother pause-and-resume, added in 2026 updates, extends this further.

Business outcome: long tasks can span interruptions without restarting, which matters for real work that rarely finishes in one sitting.

Native Issue and Pull Request Context via MCP

Built on GitHub's native MCP integration, the agent can search issues, analyse labels and activity, and summarise scope. That means work can begin from the backlog itself rather than from a hand-written prompt. The AI GitHub tools ecosystem benefits from this because the agent already understands repository structure.

Business outcome: less time spent re-explaining tickets to an AI, and faster movement from backlog to implementation.

AGENTS.md and Skills for Consistent Behaviour

AGENTS.md and Agent Skills define custom instructions and tool access so behaviour stays consistent across models, sessions, and delegated work. For organisations, this is the mechanism that turns an ad-hoc assistant into a governed one. It also allows teams to encode house conventions once rather than repeating them in every prompt.

Business outcome: consistent agent behaviour across a team, with conventions enforced rather than hoped for.

CLI to IDE and Back Without Losing Work

A developer can start in the CLI with a plan, open the work in VS Code to refine code directly, and return to the terminal. Because the tool is editor-independent, it modifies files that any editor then displays. This matters for teams that have not standardised on a single IDE and do not intend to.

Business outcome: no forced editor migration, and no lost work when developers move between tools.

• No separate purchase decisionBecause it is bundled across every Copilot tier, adoption is a configuration change rather than a new procurement cycle.
• Genuinely editor-independentIt modifies files any editor can display, which removes the lock-in that editor-native agents often create.
• Native GitHub contextDirect MCP-based access to issues, labels, and pull request activity means the agent starts with real project context.
• Parallel execution is realFleet execution across subagents and multiple models compresses time on large, decomposable tasks rather than just promising to.

• Subscription-gated capabilityThere is no way to use the CLI without an active Copilot subscription, so it cannot be evaluated as a standalone tool.
• Capabilities vary by tierWhat a user can actually do depends on which Copilot plan they or their organisation hold, so two teams may have different experiences.
• Terminal and file access is a real risk surfaceAn agent with terminal and file-modification permissions should be reviewed like any tool with that level of system access.
• Professional RealityTreat this as a governed capability, not a convenience: define what the agent may touch, review its changes like any other contributor's, and confirm which plan entitlements your organisation actually has before rolling it out broadly.

Platform teams automating repository work

Engineers managing infrastructure and shared repositories can use the agent to handle repetitive repository tasks — searching issues, summarising scope, and preparing changes — without leaving the shell. The native GitHub context means the agent already understands the project structure it is working in.

Developers working across multiple editors

Teams that have not standardised on a single IDE benefit most from an editor-agnostic agent. Work can start in the terminal, move into whichever editor a developer prefers, and return to the CLI without losing state, which removes a coordination cost that editor-native tools impose.

Organisations standardising agent behaviour

Using AGENTS.md and Agent Skills, an organisation can define custom instructions and tool access once and have them apply consistently across models and sessions. For teams already invested in Copilot Enterprise, this is the governance layer that makes broad rollout defensible.

Individual developers on existing plans

Anyone already paying for Copilot Free, Pro, or higher gets the CLI at no extra cost, making it a low-friction addition to an existing workflow. The main investment is learning the command vocabulary — /plan, /fleet, /model, /resume — rather than budget.

Confirm your Copilot subscription tier — the CLI requires an active Copilot plan, and your capabilities depend on which one you hold.

Install using the script (curl -fsSL https://gh.io/copilot-install | bash) or via npm with npm install -g @github/copilot.

Authenticate against your GitHub account and verify the agent can read the repository you intend to work in.

Run /plan on a small, low-risk task first, review the plan before execution, then move to autopilot mode once you are comfortable with its behaviour.