Assisted permissions in GitHub Copilot CLI: the middle ground between approving everything and --yolo

GitHub Copilot’s assisted permissions (assisted permissions) in Copilot CLI, the Copilot app, and VS Code allow a model to review each agent request and approve only those it considers safe; the rest it continues to ask you about. They’ve been generally available since October 26.

If you use the Copilot agent daily, you know the two options that existed until now. Manual approval is safe, but it interrupts you every few seconds. Allow-all mode (--allow-all, --yolo) eliminates interruptions and, with them, your control over each action. Assisted permissions are GitHub’s proposal for the middle ground.

What are assisted permissions in GitHub Copilot?

They’re a permissions mode in which a model, not you, makes the first decision about eligible requests. According to GitHub’s documentation, there are three types of eligible requests:

  • execute a command
  • access a file system path
  • open a URL

For each one, the model checks whether the action is safe and whether it’s within the authority you gave Copilot for the task. The result is one of two:

  • It’s confident it’s safe: Copilot approves it and continues without asking you.
  • It’s not sure: Copilot asks you, exactly as it would with manual approval.

Some things fall outside the review. Requests you already had permission for execute without asking and without passing through the model. Denial rules and enterprise restrictions continue to apply. Other tool calls that enterprise rules require approval for, and requests to bypass the local sandbox, aren’t reviewed by the model: they follow the normal permissions flow of the session. If review isn’t available or can’t evaluate a request, that request also goes back to the normal flow.

The model that does the review isn’t necessarily the same one you’re conversing with. Copilot chooses the reviewing model; if it’s not available, the review can use the active model from your session. If you use your own model provider, the review always uses the active model from the session.

Assisted permissions, manual approval, or --yolo?

Mode Model Review When It Asks You Oversight
Manual approval No On every action not already permitted (single approval or for the whole session) Maximum
Assisted permissions Yes, on eligible requests Only when the model isn’t sure Fewer interruptions, no global permission
Allow-all (--allow-all, --yolo, /permissions allow-all, /yolo) No Never None per action

The practical difference: allow-all grants trust upfront for the whole session. Assisted permissions grant it request by request, based on a judgment about that specific action.

How do you activate them in Copilot CLI, the app, and VS Code?

In Copilot CLI

Within an interactive session:

  • /permissions assisted activates them for the current session only
  • /permissions manual reverts to manual approval
  • /permissions show shows the current mode
  • /permissions with no arguments opens a list to choose from

To make it the default mode for all new interactive sessions, add this to ~/.copilot/settings.json:

{
  "defaultPermissionMode": "assisted"
}

Change it to "manual" to revert.

For non-interactive runs (scripts, CI), use the flag or environment variable:

copilot -p "Fix the failing tests" --assisted-approval
COPILOT_ASSISTED_APPROVAL=true

--assisted-approval is only for non-interactive runs: if you use it to start an interactive session, the command ends with an error.

In the GitHub Copilot app

Open the mode menu, choose Tool permissions and then Assisted. This also saves it as the default for new local sessions. To change only the current session, type /permissions assisted in the prompt box.

In VS Code

Select Assisted permissions in the chat permissions selector. According to VS Code’s documentation, there are three conditions:

  • The option isn’t available in sessions with the Local harness.
  • You have to choose Folder isolation: sessions in Worktree always use Allow all.
  • The first time you choose this level, a warning dialog asks for confirmation.

The level new sessions start with is defined by the chat.permissions.default configuration.

What happens in autopilot mode and in CI?

In autopilot mode and non-interactive runs there’s no one to ask, so requests that would need your approval are denied. The model’s explanation goes back to Copilot, so the agent can try another path instead of getting stuck.

For automation, this is what matters most: with assisted permissions, an unattended run closes negatively on anything the model isn’t sure about.

How do you block --yolo for the whole team?

Here the feature becomes a governance tool. Enterprise administrators can use enterprise-managed settings to control which modes developers can use:

  • permissions.disableBypassPermissionsMode: "disable" blocks unconditional approval (allow-all) without disabling assisted permissions
  • permissions.disableAssistedPermissionsMode: true disables assisted permissions
  • permissions.defaultMode sets a managed default mode for new sessions, which takes priority over each developer’s defaultPermissionMode

Developers can switch to any other mode the policy allows. If the configured default mode isn’t available or is prohibited, the session starts with manual approval.

The first option is the interesting one. Until now, a team that wanted fewer interruptions had to tolerate its developers using --yolo. Now an administrator can take --yolo off the table and leave assisted permissions as the fast option.

Reference: Configuración administrada por la empresa - GitHub Enterprise Cloud Docs

Is it safe to use without sandbox?

Not on its own, and GitHub says so plainly. Its documentation warns that the model can be wrong and approve dangerous or unwanted actions, and that the feature doesn’t replace sandboxing or access restrictions. Fewer interruptions don’t take away your responsibility for what Copilot does.

Before putting this in a pipeline, there are two details of the CLI worth reviewing:

  1. Flags don’t cancel each other out. --assisted-approval overrides --allow-all-tools, but --allow-all-paths and --allow-all-urls still apply. If you combine assisted permissions with --allow-all or --yolo, access to paths and URLs can be unrestricted.
  2. It can fail silently. If assisted permissions can’t be activated (for example, because enterprise settings block them), the CLI writes a warning to standard error output and any --allow-all-tools you passed still applies. In automated runs, check stderr for that warning.

One more for enterprise environments: in the CLI, enterprise ask rules for shell commands, file reads, file writes, and URLs can be satisfied with model approval. An ask rule no longer guarantees a person sees the request.

The sensible configuration is to use assisted permissions within an isolated environment, not instead of one. We explain how to activate Copilot’s local sandbox here: GitHub Copilot Local Sandbox: How to Activate It in CLI, App, and VS Code and What It Doesn’t Block.

What Copilot plans is it available on?

At the time of publishing this note, neither the changelog nor GitHub’s documentation indicated which Copilot plans include assisted permissions.


And you? What action would you never let a model approve without asking you?

What permissions mode will you use with Copilot?
  • Manual approval
  • Assisted permissions
  • Allow-all / --yolo
  • I prefer another option (tell us which)
0 votantes

Comment below or, if you got this article by email, reply directly to the email: your reply gets published here.

Related: GitHub Copilot Bets on Autonomy — And Builds the Guardrail to Contain It