skip to content

In VS Code, after you approve a plan from Copilot's Plan agent, which actions will the agent still stop to ask you about while implementing it?

level: middleimportance: nice to knowfreq 5%

answer

  1. two separate approvals
  2. a plan file the agent keeps
  3. Start Implementation switches agents
  4. the session's permissions still rule
  5. Autopilot is the exception to watch

basics

~20 s

Approving a plan only starts implementation; it approves no tool calls. File edits, terminal commands and external tool calls still follow the session's permission level and approval settings, unless you start with an Autopilot option.

solid answer

~40 s

VS Code's docs state that approving a plan and approving tool actions are separate decisions. In a **Local** session, the built-in **Plan** agent researches without editing project files by default and keeps its plan in session memory at `/memories/session/plan.md`; **Start Implementation** switches to **Agent** and submits the request. In a **Copilot** session, `/plan` or the mode picker starts Plan mode, and the **Review Plan** card offers **Implement Plan**, **Approve Plan Only**, **Implement with Autopilot** and **Reject**. Either way, under Manual permissions the implementing agent still asks before commands such as `rm`, edits to files matched by `chat.tools.edits.autoApprove` rules set to `false`, and any tool you have not auto-approved. The Autopilot options are where that changes: Local's **Start with Autopilot** (Preview) auto-approves edits, commands and external tools, so check the session's permissions before choosing one.

go deeper

for a junior

Recall how to start planning: the Plan agent or /plan. Know that approving the plan is not the same as approving commands.

for a middle

Explain the Review Plan actions, where the Local plan is stored, and which actions still prompt under Manual permissions during implementation.

for a senior

Show you check the permission level and sandbox before choosing an Autopilot option, and use Approve Plan Only to switch models deliberately.

for a principal

Weigh plan review as a team gate against its cost, and whether organization policy should restrict Autopilot from plans.

## Two Plan experiences Copilot in VS Code offers planning in two session types, and the controls differ. | | **Local** session | **Copilot** session (Agent Host) | |---|---|---| | How to start | Select **Plan** in the agents dropdown, or type `/plan` | Type `/plan`, or select **Plan** in the agent mode picker | | Where the plan lives | Session memory: `/memories/session/plan.md` | A plan file opened from the **Review Plan** card | | Go to code | **Start Implementation** switches to **Agent** and submits | **Implement Plan** approves and implements in the session | | Autonomous option | **Start with Autopilot** (Preview) | **Implement with Autopilot** | In a Local session the Plan agent researches your project **without editing project files** by default. You read its plan with **Chat: Show Memory Files**; the plan is not a project file until you choose **Open in Editor**, which asks Agent to create an untitled copy you can save. In a Copilot session the agent researches, asks clarifying questions, and presents a **Review Plan** card. **Open Full Plan** opens the plan in the Markdown editor, where you can edit it or add inline comments; **Submit Feedback** sends your comments back without approving. Pending feedback disables approval until you submit or clear it. ## Reviewing before you approve The planning docs suggest checking a plan on four points before choosing an implementation action: - **Scope** — it solves the requested problem and leaves out unrelated changes. - **Project fit** — it names the affected files and reuses existing patterns. - **Decisions** — assumptions, dependencies and open choices are explicit. - **Verification** — the proposed tests and manual checks would show the change works without breaking existing behaviour. The review controls save your edits to the plan file before they submit approval or feedback, so an edited plan is the one the agent implements. In a Local session, the dropdown next to **Start Implementation** can also offer **Continue in** destinations to hand the plan to another supported session; the handoff carries the conversation history and context. ## What approving does | Action (Copilot session) | Effect | |---|---| | **Implement Plan** | Approves the plan and starts implementation in the current session | | **Approve Plan Only** | Approves without executing | | **Implement with Autopilot** | Approves the plan and continues autonomously in Autopilot | | **Reject** | Declines; nothing is implemented | None of these is a tool approval. The docs put it directly: approving a plan and approving tool actions are separate decisions, so review the session's permissions before implementation starts. ## What still asks you Under the default **Manual permissions** level, the implementing agent still stops for: - **Terminal commands** that no auto-approve rule allows — by default including `rm`, `del`, `kill`, `curl`, `wget`, `eval`, `chmod` and `chown`. - **Edits to sensitive files** that a `chat.tools.edits.autoApprove` pattern marks `false`, such as `**/.env`. - **Tools and URLs** — MCP and extension tools without a saved approval, and URL requests or responses not auto-approved. An ordinary prompt such as "plan first and don't change files" guides the agent but does not change those permissions either; only selecting Plan or using `/plan` starts the dedicated workflow. ## The Autopilot exception Autopilot is where planning and approvals meet. In a Local session, **Start with Autopilot** (Preview) starts implementation with automatic approval of file edits, terminal commands and external tool calls, and keeps going on its own; an organization can restrict the option. In a Copilot session, **Implement with Autopilot** hands the approved plan to Autopilot, which is built to keep working without stopping for you. Read the plan's verification steps, the session's permission level and whether the terminal sandbox is on before you pick either. ## Settings that shape planning 1. `chat.planAgent.defaultModel` — the default model for the Local Plan agent. 2. `github.copilot.chat.planAgent.additionalTools` (Experimental) — extra research tools for it, which can reach beyond read-only project access. 3. `github.copilot.chat.switchAgent.enabled` (Experimental) — lets Agent decide to switch to Plan for complex tasks. To plan with a strong model and implement with a cheaper one in a Copilot session, choose **Approve Plan Only**, change the model, switch the mode picker from **Plan** to **Interactive**, and ask the agent to implement the approved plan.

  • Where does the Local Plan agent keep its plan, and how do you keep a copy in the project?
    It stores the plan in session memory at `/memories/session/plan.md`, not as a project file; run **Chat: Show Memory Files** to read it. **Open in Editor** switches to Agent and asks it to create an untitled copy, which you can save into the project or attach to another session.
  • How do you plan with one model and implement with another in a Copilot session?
    Choose **Approve Plan Only** when it is offered and let the planning request finish. Then pick the implementation model, switch the mode picker from **Plan** to **Interactive**, and ask the agent to implement the approved plan in the same conversation.

  • Approving the plan pre-approves every terminal command it lists.
  • A prompt saying do not edit files changes the session's permissions.
  • The Local Plan agent saves its plan as a file in the project root.
  • Submitting feedback on the Review Plan card also approves the plan.