GitHub Copilot Harness Security: Patch, Pin and Govern Your Coding Agents

GitHub Copilot Harness Security: Patch, Pin and Govern Your Coding Agents

TL;DR

In one week VS Code fixed ten security advisories, eight of them involving MCP servers, agent tools or the agent host, and froze the Local harness for removal in February 2027. Visual Studio moved Copilot Chat onto the Copilot harness, Copilot CLI tied its built-in MCP server to policy, and Git fixed a clone bug that an agent can trigger just by following Git’s own advice.

Treat the editor fleet like any other agent runtime. Patch to a version floor, pin everyone to the Copilot harness (the one that enforces managed sandbox and permission policy), police MCP, permissions and customisations through Copilot’s managed settings, and prove it with diagnostics, telemetry and a test you expect to fail.

In a hurry? Jump to the version floor, the managed baseline or how to prove it, then come back for the why.

Three weeks ago, in Part 2 of my GitHub Copilot agents guide, I described a Copilot session as three choices: a harness, where it runs and a model. For an organisation relying on Copilot’s managed runtime controls, the choice of harness matters.

The editor used to be the place you typed code. Now it hosts an agent that starts MCP servers, calls tools, runs terminal commands and clones repositories on your behalf. That makes your editor fleet an agent runtime, and an agent runtime needs what any other runtime needs: a patch level, a supported configuration and a policy you can prove. This post is the baseline I’d hand a platform team rolling coding agents out to hundreds of developers.

The guidance below draws on release notes, advisories and docs available on 20 November 2026.

One week, four release trains

Here’s what landed between 10 and 18 November.

flowchart TB
    accTitle: Coding agent releases between 10 and 18 November 2026
    accDescr: On 10 November VS Code 1.145.3 fixed ten advisories, Git 2.56.1 fixed six CVEs and Visual Studio 18.12 moved Copilot Chat onto the Copilot harness. On 11 November VS Code 1.146 froze the Local harness. On 12 and 13 November Copilot CLI 1.0.110 to 1.0.112 tied the built-in MCP server to policy and made /compact and sub-agents respect the session credit limit. On 17 and 18 November VS Code 1.147, Visual Studio 18.12.1 and Copilot CLI 1.0.114 followed.
    subgraph D10["10 November"]
      A1["VS Code 1.145.3
ten security advisories"]:::sec A2["Git 2.56.1
six CVEs, code execution on clone"]:::sec A3["Visual Studio 18.12
Copilot Chat on the Copilot harness"]:::rel end subgraph D11["11 November"] B1["VS Code 1.146
Local harness frozen, removal February 2027"]:::rel end subgraph D13["12 to 13 November"] C1["Copilot CLI 1.0.110 to 1.0.112
MCP follows policy, credit limits hold"]:::rel end subgraph D18["17 to 18 November"] E1["VS Code 1.147
allowed harnesses, regex shell rules"]:::rel E2["Visual Studio 18.12.1
Copilot CLI 1.0.114"]:::rel end A3 --> B1 --> C1 --> E1 classDef sec fill:#fee2e2,stroke:#b91c1c,color:#000 classDef rel fill:#e0f2fe,stroke:#0369a1,color:#000

Four release trains, one direction. Security fixes are in red. Most of the rest moved more work onto the Copilot harness or tied the agent more tightly to policy.

Ten advisories in one patch

VS Code 1.145.3 shipped fixes for ten GitHub security advisories, all published on 10 November. Four of them sit squarely in the agent stack:

The MCP installation links advisory, CVE-2026-114171, covers crafted vscode:mcp/install links. An input definition could run a command once the user approved the install. Its CVE base score is 8.8.

The MCP elicitation notifications advisory, CVE-2026-120779, covers the fallback notification for MCP elicitation. Server-controlled text could become a clickable VS Code command link; exploitation required a user to click it. Its base score is 9.6.

The legacy SSE endpoints advisory, CVE-2026-119983, covers the MCP client’s legacy SSE transport. A server could provide an endpoint that directed later requests somewhere unintended. Its base score is 8.8.

The agent-originated local commands advisory, CVE-2026-120782, covers the Agent Host. Local-command syntax in an agent’s message could run without the expected terminal approval. Its base score is 7.8.

Four more involve agents indirectly. Three let a workspace start an MCP server without a trust prompt: a network workspace file treated as trusted, a __proto__ key in .vscode/mcp.json or settings.json, and a value that switched Workspace Trust off. The fourth let the agent-driven browser upload local files without path approval. The last two fixes cover the serve-web server and JavaScript debugger auto-attach.

A note on scores: the figures above are Microsoft’s base scores from the CVE records. GitHub’s advisory pages show lower temporal scores for the same issues, so your scanner may report 8.3 where the CVE record says 9.6.

flowchart TB
    accTitle: Where the November VS Code advisories hit the agent stack
    accDescr: A developer works in VS Code. VS Code's MCP client and the Copilot harness in the Agent Host talk to MCP servers, the Agent Host also drives the terminal and the integrated browser, and workspace configuration decides what starts. Fixes landed for MCP install links, elicitation notifications and legacy SSE endpoints, agent-originated local commands, an agent-driven browser upload, and three workspace trust bypasses that started MCP servers.
    DEV["Developer"]:::user --> VS["VS Code"]:::host
    VS --> AH["Agent Host
Copilot harness"]:::host VS --> WS["Workspace configuration
mcp.json and settings.json"]:::comp AH --> MCP["MCP servers"]:::comp VS --> MCP AH --> TERM["Terminal"]:::comp AH --> BR["Integrated browser"]:::comp MCP --- F1["Install links, elicitation
notifications, legacy SSE"]:::fix TERM --- F2["Agent-originated
local commands"]:::fix BR --- F3["Upload without
path approval"]:::fix WS --- F4["Three trust bypasses
that started MCP servers"]:::fix classDef user fill:#f1f5f9,stroke:#334155,color:#000 classDef host fill:#cce5ff,stroke:#0f172a,color:#000 classDef comp fill:#e0f2fe,stroke:#0369a1,color:#000 classDef fix fill:#fee2e2,stroke:#b91c1c,color:#000

The attack surface is the agent’s toolbelt. Eight of the ten fixes sit where the agent meets the outside world: MCP servers, the terminal, the browser and the workspace files that decide what starts.

The agent-originated command bug is the one I’d show a platform team. It lived in the Agent Host, the process that runs Copilot harness sessions, so it shows two things at once: approval only works when the runtime knows who’s asking, and the harness you pin still needs patching.

sequenceDiagram
    accTitle: How an agent-originated local command could skip terminal approval before VS Code 1.145.3
    accDescr: Untrusted repository instructions shape the agent's next message. Before the fix, local-command syntax in that message was treated as if the developer had typed it and ran without terminal approval. From 1.145.3 the Agent Host tracks where each message came from and handles local commands only when the developer typed them.
    autonumber
    participant R as Untrusted repo instructions
    participant A as Agent
    participant H as Agent Host
    participant T as Terminal
    Note over A,H: Precondition: the user granted the related session tool operation
    R->>A: Instructions shape the agent's next message
    A->>H: Message contains local-command syntax
    alt Before 1.145.3
      H->>T: Treated as typed by the developer, runs without approval
    else 1.145.3 and later
      H->>H: Tracks where the message came from
      H-->>A: Agent text isn't handled as a local command
    end

Approval only works if the runtime knows who’s asking. The fix tracks where each message came from. The advisory’s own workaround reads like the rest of this post: use the Copilot harness instead of the Local harness, keep terminal approvals on, and don’t grant session-wide permissions in repositories with untrusted instructions.

Pin: the harness is now the policy boundary

The Copilot harness has been the default for new sessions since VS Code 1.143. It’s built on the Copilot SDK and runs in the Agent Host, the process that runs Copilot sessions. VS Code 1.146 deprecated the Local harness: it’s functionally frozen and will be removed in February 2027, along with the vscode.temporaryDefaultToLocalHarness setting.

The reason matters more than the date. The 1.146 release notes say the Copilot harness “enforces managed sandbox and permission policies that the Local harness doesn’t”. The third-party harnesses are no better from a policy point of view: VS Code 1.147 notes that Claude and Codex sessions “run without Copilot’s managed permission, sandbox, MCP, and plugin controls”. Under Copilot managed settings they’re off unless you permit them with vscode.allowedHarnesses, which for now works only in file-based or MDM-managed settings. It doesn’t override temporaryAllowLocalHarness: false, so the baseline below keeps Claude and Codex off for everyone.

flowchart TB
    accTitle: Which VS Code harnesses enforce your managed policy
    accDescr: Under Copilot managed settings, a new session can use the Copilot harness, which enforces managed sandbox, permission, MCP and plugin controls. The Local harness is frozen and will be removed in February 2027. Claude and Codex harnesses are off unless allowedHarnesses permits them and temporaryAllowLocalHarness isn't false, and then they run without Copilot's controls.
    S["New agent session
under managed settings"]:::q S --> C["Copilot harness
Agent Host on the Copilot SDK"]:::good S --> L["Local harness
extension host"]:::bad S --> X["Claude or Codex harness"]:::warn C --> C1["Enforces managed sandbox,
permissions, MCP and plugins"]:::good L --> L1["Frozen since 1.146
removed February 2027"]:::bad X --> X1["Off unless allowedHarnesses permits it
and temporaryAllowLocalHarness isn't false
then runs without Copilot's controls"]:::warn classDef q fill:#f1f5f9,stroke:#334155,color:#000 classDef good fill:#dcfce7,stroke:#15803d,color:#000 classDef bad fill:#fee2e2,stroke:#b91c1c,color:#000 classDef warn fill:#fef9c3,stroke:#a16207,color:#000

Policy only binds where the harness enforces it. A permission rule that the Local harness ignores isn’t a control. Pin the fleet to the Copilot harness first, then write policy for it.

VS Code’s migration guide gives the managed settings that require it:

1
2
3
4
5
6
{
"vscode": {
"temporaryAllowLocalHarness": false,
"temporaryDefaultToLocalHarness": false
}
}

The guide is explicit that temporaryAllowLocalHarness: false prohibits the Local, Claude and Codex harnesses, and that requiring the harness doesn’t turn on sandboxing or add permission rules. That’s the job of the baseline further down. Since 1.143, a managed sandbox.enabled: true or a non-empty permissions.deny also requires the Copilot harness unless the temporary Local default applies.

One runtime, several clients

The Copilot SDK isn’t just VS Code’s engine. VS Code’s docs describe it as the shared agent runtime behind VS Code, Copilot CLI and the Copilot app, and Visual Studio 18.12 joined them: “Through the SDK, Copilot in Visual Studio now runs on the Microsoft Copilot harness.” The new Visual Studio chat reads AGENTS.md at the solution root, uses your organisation’s Copilot custom instructions, lets you switch individual MCP tools on and off, and keeps a separate Copilot trusted-paths list that organisations can manage through policy. That new chat is the default for eligible accounts, but it respects an account with editor preview features turned off, and developers can switch back under Tools > Options > GitHub > Copilot > Copilot Chat.

The runtime is shared. The policy channels aren’t.

flowchart TB
    accTitle: Where Copilot policy comes from for each client
    accDescr: GitHub enterprise and organisation policies apply to every Copilot client. Copilot managed settings, delivered from the server, MDM or a file, apply to Copilot CLI, VS Code and the Copilot app. VS Code device policies come from Group Policy, configuration profiles or a Linux policy file. Visual Studio uses its own Group Policy and MCP settings.
    GH["GitHub enterprise and organisation policy
MCP servers in Copilot, Copilot CLI,
Copilot in the cloud, models, budgets"]:::gh MS["Copilot managed settings
server, MDM or file"]:::ms DP["VS Code device policies
ADMX, mobileconfig, policy.json"]:::dp VP["Visual Studio Group Policy
and its own MCP settings"]:::dp CLI["Copilot CLI"]:::client VSC["VS Code"]:::client APP["Copilot app"]:::client VS["Visual Studio 2026"]:::client GH --> CLI GH --> VSC GH --> APP GH --> VS MS --> CLI MS --> VSC MS --> APP DP --> VSC VP --> VS classDef gh fill:#cce5ff,stroke:#0f172a,color:#000 classDef ms fill:#ede9fe,stroke:#6d28d9,color:#000 classDef dp fill:#fef9c3,stroke:#a16207,color:#000 classDef client fill:#e0f2fe,stroke:#0369a1,color:#000

Same runtime, different levers. Copilot’s managed settings reach Copilot CLI, VS Code, the Copilot app and, for some keys, Copilot in the cloud and JetBrains IDEs. Visual Studio isn’t on that list, so it needs its own Group Policy baseline alongside the GitHub policies that apply everywhere.

One more thing about levers: device policies and managed settings aren’t interchangeable. VS Code’s enterprise guidance warns that a delivered value “does not establish that every harness enforces it in the same way”, and where both set the same control, the enterprise-managed setting wins. I write the rules in Copilot’s managed settings and keep VS Code device policies for editor-only controls such as UpdateMode and ChatApprovedAccountOrganizations, rather than setting the same control in both places.

Patch: set a version floor

Here’s the floor I’d set today:

  • VS Code: 1.145.3 or later fixes ten advisories, eight of them agent-related. Version 1.147.0 is the current stable.
  • Copilot CLI: 1.0.112 or later removes the built-in GitHub MCP server when policy turns MCP off, and sub-agents respect the session credit limit. Version 1.0.114 is current.
  • Visual Studio 2026: 18.12.1, or 18.11.4 if you’re staying on 18.11. The release notes list the Git for Windows fixes under 18.11.4, so check that MSRC lists your 18.12 build for CVE-2026-111760. Version 18.12 moves Copilot Chat onto the Copilot harness.
  • GitHub Copilot for JetBrains: check the applicable MSRC update guidance for CVE-2026-83953, a local information disclosure, and confirm the fixed version for your installation.
  • Git, everywhere: 2.56.1 or the patched release for your series fixes code execution when cloning a malicious repository.

Three things make the floor stick:

  • Keep updates flowing. VS Code “releases weekly updates with new features, bug fixes, and security patches”, so a floor beats a pin. If you’ve set UpdateMode to manual or none to control rollout, you own the patch cadence, including the next Tuesday fix.
  • Set a managed minimum version. VS Code’s AI settings guide describes requiring a minimum VS Code version before AI features are available, which keeps Copilot off until the client is updated. Adding sandbox to Copilot’s managed settings also blocks connections from clients older than Copilot CLI 1.0.93, VS Code 1.141.0 and the Copilot app 1.1.26, but that’s well below this floor, so treat it as a backstop for the oldest clients.
  • Refuse stale policy. forceRemoteSettingsRefresh: true makes clients fetch server-managed settings at startup. In VS Code, Copilot features are blocked until that refresh succeeds. Deliver it by MDM or file so it applies from a device’s first start.

Police: a managed baseline

mindmap
  root((Managed baseline))
    Versions
      VS Code 1.145.3 or later
      Copilot CLI 1.0.112 or later
      Git 2.56.1 or the patched series
    Harness
      Copilot harness only
      Local, Claude and Codex off
    MCP
      Allowlist by URL or command
      Denylist for known bad servers
    Permissions
      Bypass mode disabled
      Deny and ask rules for risky operations
    Sandbox and secrets
      Sandbox required with no bypass
      Local MCP servers inside the sandbox
      Masked environment variables
    Customisations
      Plugin-only customisation
      Approved marketplaces only
    Evidence
      OpenTelemetry export
      Policy Diagnostics
      Usage metrics and audit log

The baseline on one page. Most of it lives in one managed settings file. The rest is GitHub policy, Visual Studio’s Group Policy, a developer masking list and your patching process.

Here’s a starting managed-settings.json, built from the keys in GitHub’s reference plus the vscode harness keys and strictPluginOnlyCustomization from VS Code’s docs. Serve it from copilot/managed-settings.json in your .github-private repository. Server-managed settings only reach users who get their Copilot licence from your enterprise; device delivery applies regardless of who licensed them. Use MDM or file delivery where needed, including forceRemoteSettingsRefresh before first sign-in, and review precedence and the most-restrictive composition rules before combining sources. Native MDM uses individual string values, not the JSON file. Treat these rules as examples and replace them with your own:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
{
"vscode": {
"temporaryAllowLocalHarness": false,
"temporaryDefaultToLocalHarness": false
},
"forceRemoteSettingsRefresh": true,
"permissions": {
"disableBypassPermissionsMode": "disable",
"defaultMode": "manual",
"deny": ["Shell(rm -rf *)", "Read(~/.ssh/**)", "Edit(//etc/**)", "Read(~/copilot-canary/**)"],
"ask": ["Shell(git push *)", "Domain(api.github.com)"]
},
"allowedMcpServers": [
{ "serverUrl": "https://api.githubcopilot.com/*" },
{ "serverUrl": "https://mcp.example.internal/*" }
],
"deniedMcpServers": [
{ "serverUrl": "https://mcp.example.internal/experimental/*" }
],
"strictPluginOnlyCustomization": true,
"strictKnownMarketplaces": [
{ "source": "github", "repo": "OWNER/REPO" }
],
"sandbox": {
"enabled": true,
"failIfUnavailable": true,
"allowBypass": false,
"sandboxMcpServers": true
},
"telemetry": {
"enabled": true,
"endpoint": "https://otel-collector.example.com",
"protocol": "http/protobuf",
"capture": { "identity": true }
}
}

What each block does, and the traps I’d watch for:

  • MCP. The “MCP servers in Copilot” policy decides whether MCP servers run at all, and it’s off by default. When you turn it on, make allowedMcpServers the main control rather than “Registry only”: GitHub’s docs say registry enforcement matches only names or IDs, which users can bypass by editing configuration files. Match by serverUrl or serverCommand, because users choose server names, and list the URLs of any Copilot connectors you use, because the allowlist blocks those too. The sample permits remote servers only; add an exact, reviewed command and arguments for each approved local server. Visual Studio is the exception: managed settings don’t reach it, but registry enforcement does from 18.4, so decide deliberately whether to keep “Registry only” for Visual Studio users. Two gaps to know: GitHub’s documentation says the allowlist doesn’t cover MCP servers defined in repository custom agent profiles; use the cloud agent firewall to restrict their required domains and verify other execution environments separately. The built-in GitHub MCP server is exempt from the allowlist and denylist, although Copilot CLI 1.0.112 removes it when organisation policy turns MCP off.
  • Install links. The 1.145.3 patch fixes the vscode:mcp/install bug. A link opens the server details editor so the user can review the configuration before installing. On supported clients, an allowlist also limits which non-default servers can be installed or run.
  • Permissions. disableBypassPermissionsMode: "disable" neuters --yolo and --allow-all in Copilot CLI and turns off chat.tools.global.autoApprove in VS Code so it can’t be re-enabled. It doesn’t block assisted permissions, so decide separately whether to set permissions.disableAssistedPermissionsMode. Rules follow deny, then ask, then allow, and once any managed rule exists, an unmatched operation asks for approval. In VS Code these granular rules apply to Agent Host sessions, which is one more reason to pin the harness. VS Code 1.147 and Copilot CLI 1.0.111 also accept regular expressions in shell rules.
  • Sandbox. failIfUnavailable with enabled makes the sandbox mandatory: if Copilot can’t enforce it, model and tool execution stop instead of running unsandboxed. allowBypass: false stops users opting out mid-session, and sandboxMcpServers puts local MCP servers inside it too. Turning the sandbox on doesn’t block outbound network access by default, so add sandbox.userPolicy.network restrictions such as allowOutbound: false where a team can live with them. On Windows, host rules and environment variable masking need local network access, so test before you set allowLocalNetwork: false.
  • Masked environment variables. This one is a developer setting, not a managed key. In VS Code 1.146, chat.agent.sandbox.credentials.envVars takes variable names, never values, and tools see placeholders; the real values are restored only in HTTPS requests to the hosts you list in injectHosts. Copilot CLI has the same idea under /sandbox. Masking only works while the sandbox is on, so the admin lever is forcing the sandbox, and the developer lever is a masking list you ship in your standard setup.
  • Customisations. strictPluginOnlyCustomization blocks standalone skills, custom agents, hooks, MCP servers and, since 1.146, canvas extensions from user and project sources, so they arrive only through plugins or managed settings. Plugin-only isn’t a marketplace allowlist, so pair it with strictKnownMarketplaces, which also switches off the built-in marketplaces. Test both against your repositories’ skills, agents, hooks, MCP configuration and instruction files before you enforce them.

Git is part of the agent runtime

Agents clone repositories, run Git commands and read Git’s error messages. On 10 November Git released 2.56.1, with backports down to 2.50.2, fixing six vulnerabilities. The one that matters most here, CVE-2026-111760, allows code execution when cloning a malicious repository. For a recursive clone, the attacker’s code can run during the clone. For a non-recursive clone, Git can report an error and suggest running git status, and following that advice runs the attacker’s code.

That’s exactly the kind of helpful hint a coding agent follows without a second thought.

flowchart TB
    accTitle: Where Git runs in a coding agent fleet
    accDescr: Git needs version 2.56.1 or the patched release for its series on developer laptops, in apps that bundle Git such as Visual Studio, GitHub Desktop and the Copilot app, in dev container and agent sandbox images, on self-hosted runners, and on GitHub-hosted runners, where GitHub started shipping patched images on 11 November.
    G["Git 2.56.1 or the patched
release for your series"]:::good G --> L["Developer laptops"]:::yours G --> V["Apps that bundle Git
Visual Studio, GitHub Desktop, Copilot app"]:::yours G --> D["Your dev container
and agent sandbox images"]:::yours G --> S["Self-hosted runners"]:::yours G --> H["GitHub-hosted runners
patched images from 11 November"]:::theirs classDef good fill:#dcfce7,stroke:#15803d,color:#000 classDef yours fill:#fef9c3,stroke:#a16207,color:#000 classDef theirs fill:#e0f2fe,stroke:#0369a1,color:#000

Every place an agent can clone needs the fix. GitHub patched its own services and started shipping hosted runner images with Git 2.56.1 on 11 November. Laptops, bundled copies, custom images and self-hosted runners are yours, shown in yellow.

Prove the policy is working

A policy file proves nothing on its own. I ask three questions: did the policy arrive, does it bite, and does it cover the whole fleet?

flowchart TB
    accTitle: Three layers of evidence that a coding agent policy works
    accDescr: First prove delivery on a device with Policy Diagnostics and the sandbox policy view. Then prove enforcement with a canary that tries an approved action and a harmless blocked one. Then prove fleet coverage with usage metrics versions, the audit log and OpenTelemetry metrics. Drift or gaps feed back into the policy.
    P["Managed settings
and policies"]:::ms P --> E1["Delivered?
Developer: Policy Diagnostics
and /sandbox policy"]:::ev E1 --> E2["Enforced?
a canary tries one approved action
and one harmless blocked one"]:::ev E2 --> E3["Covered?
usage metrics versions,
audit log, OpenTelemetry"]:::ev E3 -- "drift or gaps" --> P classDef ms fill:#cce5ff,stroke:#0f172a,color:#000 classDef ev fill:#dcfce7,stroke:#15803d,color:#000

A delivered setting isn’t an enforced one. VS Code’s policy guide says the diagnostics report “does not prove that a restriction applies to every workflow or agent harness”. Every control gets a test you expect to fail.

  • Delivered. On a test device, run Developer: Policy Diagnostics in VS Code. It shows the applied and non-applied policy tables and the account policy gate, and Developer: Sync Account Policy forces a refresh. VS Code’s guidance pairs it with /sandbox policy in a Copilot session.
  • Enforced. Keep a canary script: open an install link for an unlisted MCP server, ask the agent to read a dummy file covered by a canary deny rule such as Read(~/copilot-canary/), start Copilot CLI with --yolo (1.0.110 and later warn when the flag is ignored), and try to start a Local harness session. Never test with the real rm -rf rule. Each one should fail, every time, and the approved workflow next to it should work.
  • Covered. The Copilot usage metrics API reports last_known_ide_version, last_known_plugin_version and the last known CLI version per user, which is how you find laptops below the floor. Data arrives within two full UTC days. The dashboards don’t include Copilot CLI usage, so use the API.
  • Changed. The audit log records policy changes as copilot.cfb_enterprise_settings_changed and copilot.cfb_org_settings_changed, but those events don’t say which setting changed. Server-managed settings live in copilot/managed-settings.json in your .github-private repository, so require pull request review on that file and the commit history gives you the diff the audit log doesn’t. The log keeps 180 days, so stream it to your SIEM.
  • Observed. The managed telemetry block sends OpenTelemetry to your collector. capture.identity attributes activity to a user and machine; review all telemetry and content-capture settings separately before deploying it. Metrics such as github.copilot.tool.call.count, github.copilot.mcp.server.connection.count and github.copilot.sandbox.operation.count show trends, but GitHub describes sandbox metrics as “not a complete audit log”.
  • Spent.** User-level budgets always hard stop. Cost centre, organisation and enterprise budgets only block if “Stop usage when budget limit is reached” is ticked, and it’s off by default. Copilot CLI’s --max-ai-credits is a soft, user-set session limit, which /compact (1.0.110) and sub-agents (1.0.112) now respect.

A rollout you can run this month

flowchart TB
    accTitle: Rollout plan for the coding agent baseline
    accDescr: This week, patch VS Code, Copilot CLI, Visual Studio, the JetBrains plugin and Git everywhere. Over the next two weeks, pilot the managed settings with a canary group and run the proof tests. By the end of January, require the Copilot harness for everyone, ahead of the Local harness removal in February 2027. Every week after that, measure version drift, blocked actions and spend.
    W1["This week · Patch
VS Code, Copilot CLI, Visual Studio,
JetBrains plugin and Git everywhere"]:::step W2["Next two weeks · Pilot
managed settings for a canary group
and run the proof tests"]:::step W3["By the end of January · Enforce
Copilot harness for everyone,
Local, Claude and Codex off"]:::step W4["Every week · Measure
version drift, blocked actions and spend"]:::step W1 --> W2 --> W3 --> W4 classDef step fill:#e0f2fe,stroke:#0369a1,color:#000

Patch first, then policy. Patching is urgent and low risk. Policy is neither: pilot it with a canary group so the first person to hit a deny rule is on your team, not a developer with a release due. Enforce the harness well before February, so the Local harness removal is a non-event.

Nine checks before you call it done

  1. Versions. Every VS Code client is on 1.145.3 or later, Copilot CLI on 1.0.112 or later, and Git on 2.56.1 or the patched release for its series, including images and runners.
  2. Harness. Sessions run on the Copilot harness, and Local, Claude and Codex are off. If a team needs Claude or Codex, treat it as a separate, documented device configuration and test what it allows, because it can’t sit alongside temporaryAllowLocalHarness: false.
  3. MCP. Servers run from an allowlist matched by URL or command, subject to the built-in server and custom agent profile exceptions. Cloud agent firewall rules restrict the required domains for those profiles.
  4. Permissions. Bypass mode is disabled, and risky operations sit in deny or ask rules.
  5. Sandbox. It’s required, it can’t be bypassed, and local MCP servers run inside it.
  6. Secrets. Developers have a standard masking list for the environment variables that hold credentials.
  7. Customisations. Plugin-only customisation and the marketplace allowlist have been tested against your repositories’ skills, agents, hooks, MCP configuration and instruction files before enforcement.
  8. Proof. A canary shows each control blocks what it should, and the usage metrics API helps identify reported clients below the floor. Last-known versions and delayed reports aren’t a complete device inventory.
  9. Visual Studio. It has its own Group Policy baseline, because GitHub doesn’t list Visual Studio as a managed settings client, and you know which developers are on the new Copilot chat.

My take

Most enterprise conversations about coding agents start with the model. I’d start with the harness. The model decides how good the suggestions are; the harness decides whether any of your policy applies. Standardise the harness before you standardise the model.

I’d also stop thinking about version pins. With weekly releases and Patch Tuesday fixes, a pin is a liability within a month. Set a floor, let updates flow above it, and use the managed minimum version and the usage metrics API to catch anything that falls behind. The Copilot harness isn’t immune either: in October, VS Code 1.141.1 fixed a flaw where it could auto-approve edits to hook and agent-definition files, and this month’s agent-originated command bug lived in the Agent Host that runs it. Pinning the harness only works alongside patching.

A few caveats. The policy surface is genuinely confusing: GitHub policies, Copilot managed settings, VS Code device policies and Visual Studio’s Group Policy overlap, and a value that reaches a device isn’t proof that every harness enforces it. Some controls, such as masking environment variables, are still developer settings. The MCP allowlist has a gap for custom agent profiles in cloud sessions. And the baseline will drift, so I’d put a monthly review in the calendar rather than treat this as a one-off.

If I had one week, I’d patch everything on Monday, turn on the managed settings for a canary group on Wednesday, and spend Friday breaking them.

Key Takeaways

  • VS Code 1.145.3 fixed ten advisories, eight of them involving MCP servers, agent tools or the agent host. Make 1.145.3 the floor, with Copilot CLI 1.0.112 and Git 2.56.1 alongside it.
  • The Copilot harness is the policy boundary. The Local harness is frozen until its removal in February 2027, and Claude and Codex sessions run without Copilot’s managed controls.
  • Put the baseline in Copilot’s managed settings: harness, MCP allowlist by URL or command, permissions, mandatory sandbox, plugin-only customisation and telemetry.
  • Visual Studio now defaults to the same runtime but sits outside managed settings, so give it its own Group Policy baseline and check which chat experience your developers actually use.
  • Patch Git wherever agents clone: a non-recursive clone plus a helpful git status hint was enough to run an attacker’s code.
  • Prove it three ways: Policy Diagnostics for delivery, a canary for enforcement, and the usage metrics API, audit log and OpenTelemetry for coverage.

References

Image Credits

  • Cover image generated by Copilot

GitHub Copilot Harness Security: Patch, Pin and Govern Your Coding Agents

https://clouddev.blog/GitHub/Copilot/github-copilot-harness-security-patch-pin-and-govern-your-coding-agents/

Author

Ricky Gummadi

Posted on

2026-11-16

Updated on

2026-11-22

Licensed under

Comments

Choose your design

Only the look changes. Your posts, ads, comments and other integrations stay in place, with the same light/dark and cookie preferences.

Choose the look you prefer