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:#000Four 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:#000The 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
endApproval 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:#000Policy 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 | { |
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:#000Same 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
UpdateModetomanualornoneto 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
sandboxto 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: truemakes 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 logThe 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 | { |
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
allowedMcpServersthe 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 byserverUrlorserverCommand, 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/installbug. 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--yoloand--allow-allin Copilot CLI and turns offchat.tools.global.autoApprovein VS Code so it can’t be re-enabled. It doesn’t block assisted permissions, so decide separately whether to setpermissions.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.
failIfUnavailablewithenabledmakes the sandbox mandatory: if Copilot can’t enforce it, model and tool execution stop instead of running unsandboxed.allowBypass: falsestops users opting out mid-session, andsandboxMcpServersputs local MCP servers inside it too. Turning the sandbox on doesn’t block outbound network access by default, so addsandbox.userPolicy.networkrestrictions such asallowOutbound: falsewhere a team can live with them. On Windows, host rules and environment variable masking need local network access, so test before you setallowLocalNetwork: false. - Masked environment variables. This one is a developer setting, not a managed key. In VS Code 1.146,
chat.agent.sandbox.credentials.envVarstakes variable names, never values, and tools see placeholders; the real values are restored only in HTTPS requests to the hosts you list ininjectHosts. 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.
strictPluginOnlyCustomizationblocks 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 withstrictKnownMarketplaces, 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:#000Every 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:#000A 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 Diagnosticsin VS Code. It shows the applied and non-applied policy tables and the account policy gate, andDeveloper: Sync Account Policyforces a refresh. VS Code’s guidance pairs it with/sandbox policyin 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 realrm -rfrule. 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_versionand 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_changedandcopilot.cfb_org_settings_changed, but those events don’t say which setting changed. Server-managed settings live incopilot/managed-settings.jsonin your.github-privaterepository, 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
telemetryblock sends OpenTelemetry to your collector.capture.identityattributes activity to a user and machine; review all telemetry and content-capture settings separately before deploying it. Metrics such asgithub.copilot.tool.call.count,github.copilot.mcp.server.connection.countandgithub.copilot.sandbox.operation.countshow 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-creditsis 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:#000Patch 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
- 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.
- 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. - 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.
- Permissions. Bypass mode is disabled, and risky operations sit in
denyoraskrules. - Sandbox. It’s required, it can’t be bypassed, and local MCP servers run inside it.
- Secrets. Developers have a standard masking list for the environment variables that hold credentials.
- Customisations. Plugin-only customisation and the marketplace allowlist have been tested against your repositories’ skills, agents, hooks, MCP configuration and instruction files before enforcement.
- 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.
- 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 statushint 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
- Visual Studio Code, release notes for 1.145, 1.146 and 1.147, and security advisories.
- Visual Studio Code, Move from the Local to the Copilot harness and manage AI settings in enterprise environments.
- Visual Studio Code, sandbox Copilot agent sessions and policy diagnostics.
- GitHub Docs, enterprise managed settings and deployment methods and precedence.
- GitHub Docs, configure an MCP server allowlist and MCP private registry enforcement.
- GitHub Docs, usage metrics, audit logs and OpenTelemetry reference.
- GitHub Docs, budgets for usage-based billing.
- GitHub, Copilot CLI releases.
- Microsoft Security Response Center, CVE-2026-83953; GitHub Advisory Database, GHSA-5pr7-c8pm-c229.
- Microsoft Learn, Visual Studio 2026 release notes and Copilot in Visual Studio upgrade.
- GitHub Blog, Git security vulnerabilities announced and runner image releases.
Related posts
- GitHub Copilot CLI vs Local vs Cloud: Agents Explained (2026): the harness, environment and model framing this post builds on.
- AGENTS.md vs Copilot Instructions vs Cursor Rules vs CLAUDE.md: Which AI Context File to Use, and When (2026): the instruction files to test before you enforce plugin-only customisation.
- AI Agents Exploit Leaked Keys in Minutes: Go Keyless on Azure: keeping credentials out of agent sessions in the first place.
- Governance for AI Agents (Part 1): The Gap, the OWASP Agentic Top 10, and Where AGT Fits: policy in front of every tool call, beyond the editor.
Image Credits
- Cover image generated by Copilot
GitHub Copilot Harness Security: Patch, Pin and Govern Your Coding Agents




