GitHub Copilot Autopilot Mode — Approval-Free Autonomous Execution to Task Completion¶

For / Key Points

Audience: Developers and DevOps engineers using GitHub Copilot in VS Code or via the CLI

Key Points:

Autopilot is a permission level that bypasses all approval dialogs and runs autonomously to task completion
Available in VS Code as "Autopilot (Preview)" and in the CLI as --autopilot --allow-all
Stop conditions and cap settings prevent runaway execution

What Is Autopilot?¶

You issue one instruction, and Copilot edits files, runs tests, detects failures, fixes them, re-runs tests, confirms they pass, and declares completion — that's Autopilot in action.

Traditional Agent mode displays an approval dialog every time it writes a file or executes a command. Autopilot bypasses all of these approvals and runs autonomously to completion based on AI judgment.¹

The key point: Autopilot is available in both VS Code and the CLI. In VS Code you select "Autopilot (Preview)" from the permission picker; in the CLI you enable it with the --autopilot flag.¹² The names and UI differ, but the essence is identical — automated approvals + auto-responses to AI questions + autonomous continuation to task completion.

Positioning in VS Code and CLI¶

Autopilot's positioning differs slightly between VS Code and CLI. The interactive diagram below shows both environments and the execution flow.

VS Code: Three Permission Levels¶

In VS Code's Copilot Chat, you select a permission level within Agent mode.²

Permission Level	Approval Dialogs	AI Questions	Autonomous Continuation
Default Approvals	Shown each time	Shown each time	None
Bypass Approvals	Auto-approved	Shown each time	None
Autopilot (Preview)	Auto-approved	Auto-answered	To task completion

The design is tiered. Default keeps the traditional manual approval. Bypass skips approvals only — AI questions still require human answers. Autopilot automates both, achieving full autonomous execution.

CLI: Four Operation Modes¶

In the CLI, Autopilot is offered as a standalone operation mode.¹³

Suggest — code completion only, no chat
Interactive — waits for human approval at each step (default)
Plan — builds an implementation plan before executing
Autopilot — runs to task completion from a single instruction

Press Shift+Tab to cycle modes.¹ The recommended workflow is to build a plan in Plan mode, then select "Accept plan and build on autopilot" to transition straight to autonomous execution.

How They Map¶

VS Code	CLI	Common Behavior
Agent + Default Approvals	Interactive	Approval each time. Human keeps the wheel
Agent + Bypass Approvals	`--allow-all`	Approvals skipped. Questions still stop
Agent + Autopilot (Preview)	`--autopilot --allow-all`	Fully automatic. Runs to task completion

Click each card in Panel 1 of the widget to see detailed descriptions.

When Does It Stop? — Stop Conditions and Safety Design¶

Because Autopilot runs autonomously, the design of "when it stops" matters critically. There are four stop conditions.¹

Task complete — the AI determines the task is finished
Blocking problem — an unresolvable issue (insufficient permissions, dependency errors, etc.) is detected
Manual interrupt — the user presses Ctrl+C (or the Stop button in VS Code)
Limit reached — the CLI's --max-autopilot-continues step cap is hit

The CLI's --max-autopilot-continues flag is especially important and strongly recommended for CI/CD pipelines and scripted execution.¹ It's a physical safety valve against infinite loops.

Permission Decision¶

When entering Autopilot in the CLI, three options are presented.¹

Grant all permissions (recommended) — allow all file edits, command execution, and URL access
Continue with limited permissions — automatically skip operations requiring approval
Cancel

With limited permissions, every file write or test execution that needs approval gets auto-skipped, leaving tasks incomplete. VS Code's Autopilot (Preview) defaults to full permissions, so this decision is unnecessary there.

Try the slider and toggle in Panel 3 of the widget to see how these settings affect behavior.

How Does Cost Change? — Premium Request Consumption¶

Autopilot follows the same billing principle as standard mode. Each user prompt and each AI continuation step consumes premium requests.¹

Internal tool calls (file read/write, terminal execution) themselves are not billed. What's consumed is each "continuation step" where the AI model performs inference.

Aspect	Standard Mode	Autopilot
Billing trigger	Each time user hits Enter	Automatically per continuation step
Internal tool operations	Not billed	Not billed
Cost predictability	High (user-controlled)	Low (AI-driven)
Cap mechanism	None (user self-limits)	CLI: `--max-autopilot-continues`

Play the animation in Panel 4 ("Cost Comparison") of the widget to intuitively see how consumption patterns differ.

Practical Cost Control¶

Three approaches help manage unpredictable consumption.

CLI: --max-autopilot-continues sets a physical cap (e.g., 10 steps)
/model command checks the current model and its multiplier before execution¹
Auto model selection (0.9 coefficient) provides a permanent 10% discount⁴

With the CLI's --max-autopilot-continues 10, the worst case is model multiplier x 11 requests (initial + 10 continuations). Even with Opus 4.6 (3x), that caps at 33 requests.

How It Differs from Claude Code auto-mode¶

Copilot's Autopilot and Claude Code's auto-mode both offer "autonomous execution." However, their permission and stop designs diverge.

Comparison Axis	Copilot Autopilot	Claude Code auto-mode
Permission model	VS Code: 3-tier permission picker / CLI: `--allow-all`	`--dangerously-skip-permissions` for full grant
Stop conditions	AI judgment / blocking problem / Ctrl+C / step cap	AI judgment / Ctrl+C / context limit
Cap setting	CLI: `--max-autopilot-continues N`	No explicit step cap (time-based throttling)
Cost model	Premium requests x model multiplier	Flat subscription ($20/month+) with time-based limits

The design philosophy is clear. Copilot stops by count; Claude Code throttles by time. Copilot charges per step, making step caps rational. Claude Code's flat pricing removes the incentive for step limits.

This isn't about which is better — it's about matching tools to tasks. Well-defined tasks (adding tests, refactoring, fixing CI) suit Autopilot. Exploratory development fits Claude Code's flat model, where consumption anxiety doesn't constrain iteration.

Getting Started¶

Enabling Autopilot in VS Code¶

Open the Copilot Chat panel
Select Agent mode
Choose "Autopilot (Preview)" from the permission picker²
Send your prompt

That's all it takes to start approval-free autonomous execution. You can also change the default permission level via VS Code settings.

Switching Mid-Session in the CLI¶

# Start normally
copilot

# Press Shift+Tab to cycle through modes
# Suggest → Interactive → Plan → Autopilot

Starting Directly in Autopilot via CLI¶

# Autopilot + full permissions + 10-step cap
copilot --autopilot --allow-all --max-autopilot-continues 10 \
  "Refactor everything under src/"

CI/Script Automation¶

# Programmatic execution (no interactive UI)
copilot --autopilot --yolo --max-autopilot-continues 10 \
  -p "Increase test coverage to 80%+"

The -p flag passes a prompt directly, bypassing the interactive UI.¹ Always set --max-autopilot-continues when embedding in CI pipelines.

Knowing When to Use It¶

Autopilot shines on tasks with clear goals and limited scope.¹

Adding or fixing tests (against existing code)
Refactoring (renaming, type cleanup, structural changes)
CI/CD fixes (resolving build errors)
Batch code generation (CRUD, boilerplate)

It's poorly suited for exploratory development with vague goals, design work requiring nuanced judgment, and open-ended feature development.¹ For those, Default Approvals (VS Code) or Interactive (CLI) keep human hands on the wheel — and incidentally prevent wasting premium requests.

Summary¶

Autopilot works in both VS Code and CLI — VS Code via the permission picker, CLI via the --autopilot flag
The essence is "approval bypass + autonomous continuation" — not just skipping approval dialogs but also auto-answering AI questions to run to task completion
Safety is tiered — VS Code offers 3 permission levels, the CLI uses --max-autopilot-continues for step caps

Autopilot isn't a "delegate-everything mode." The value of autonomous execution lies in choosing the right tasks to delegate and configuring appropriate safety valves. Start with Default Approvals to get comfortable with Agent mode, learn the nature of your tasks, and graduate to Autopilot when ready — that staged approach is the most practical.

Copilot CLI Practical Guide
From installation to daily workflows with the CLI
Premium Request Optimization
Multiplier tables and anti-patterns for optimizing consumption
Multi-Agent Collaboration Guide
Copilot x Claude Code x Codex role division strategies
Reasoning Levels Guide
Model selection and reasoning level optimization