GitHub MCP allowlists, 6 August 2026: what platform teams must change now

GitHub's MCP allowlist landed 6 August 2026, one day after VS Code deleted the agent-host admin policy.

Read time
16 min
Word count
2.9K
Sections
14
FAQs
8
Share
Diagram of a GitHub MCP allowlist gateway filtering connectors into a managed IDE fleet
GitHub made allowedMcpServers and deniedMcpServers generally available on 6 August 2026.
On this page · 14 sections
  1. What GitHub shipped on 6 August 2026
  2. The three matchers, and what each one is worth
  3. GitHub says the registry method is not a hard boundary
  4. Four precedence layers, and which one wins
  5. The control you lost on 5 August
  6. Client coverage: where the allowlist actually applies
  7. A managed-settings.json you can start from
  8. Why the vendor shipped this in August
  9. What to do this month
  10. India-specific considerations
  11. Cost framing before you scope the work
  12. FAQ
  13. How eCorpIT can help
  14. References

Summary. On 6 August 2026 GitHub made allowedMcpServers and deniedMcpServers generally available in enterprise managed settings, giving enterprise owners their first central switch over which Model Context Protocol servers Copilot clients may run. One day earlier, on 5 August 2026, VS Code 1.132 removed the ChatAgentHostEnabled policy, so administrators can no longer disable the agent host that runs Copilot, Claude and Codex harnesses in a separate process. Both changes matter to the same person: whoever owns a managed IDE fleet. The allowlist launched on 3 Copilot clients; by 11 November 2026 GitHub also lists JetBrains IDEs and cloud sandbox sessions, but still no Xcode or Eclipse install. GitHub's docs now make clear that its bypass warning covers only the older registry-based restriction, not these keys. At $19 per granted seat per month for Copilot Business and $39 for Copilot Enterprise, a 200-seat team is paying $7,800 a month, so the connector policy deserves the same review as any other production control. This guide covers what shipped, what the matchers actually match, the 4 precedence layers, and the config to commit this month.

What GitHub shipped on 6 August 2026

The GitHub Changelog entry is short and precise: "Enterprise owners can now centrally control which Model Context Protocol (MCP) servers GitHub Copilot clients are allowed to run by using the new allowedMcpServers and deniedMcpServers keys in enterprise managed settings."

The keys live in a file, not a settings page. You add them to copilot/managed-settings.json in your source organisation's .github-private repository and commit to the default branch. That is the same delivery mechanism GitHub already uses for plugin standards and telemetry configuration, so most enterprises that have done any Copilot governance already have the repository.

Three things about the semantics are easy to get wrong on the first commit:

An unset allowedMcpServers allows every non-default server. An empty array blocks all of them, which is the deny-all posture. An unset or empty deniedMcpServers blocks nothing. And deny always wins: a server that matches deniedMcpServers is blocked even when it also matches allowedMcpServers.

GitHub also states that "Policies fail closed, meaning a malformed or unverifiable configuration is blocked rather than allowed. When policies come from multiple layers, a server must pass every layer." Fail-closed is the right default, but it has an operational consequence worth planning for: a bad commit to managed-settings.json does not degrade gracefully into the old behaviour. It blocks connectors for everyone on the next client sync. Treat that file like a firewall rule set, with review and a rollback commit ready.

The three matchers, and what each one is worth

Each key holds a list of matchers. There are three matcher types, and they are not equally trustworthy.

Matcher What it matches Practical strength
serverUrl Remote HTTP and SSE servers, with wildcard support and URL canonicalisation Strongest of the three. A URL is hard to spoof from inside the IDE without also changing where traffic goes
serverCommand Local stdio servers, by exact command and arguments Brittle by design. An extra flag, a different absolute path or a wrapper script produces a different command string
serverName The user-assigned label shown in the client Weakest. GitHub states it "is only supplied as a convenience, not a security control, since users can rename servers"
Registry policy Servers published in your configured MCP registry, under the "Registry only" setting Broader net, but registry membership is matched on server ID, which the client config also controls
No policy set Every non-default server the developer installs The current state in most organisations

The serverName caveat is GitHub's, verbatim, and it sets the honest ceiling on this feature. If your threat model includes a developer who wants to run an unapproved connector, name matching does not stop them. If your threat model is an engineer who installs a plausible-looking community MCP server without thinking about it, name and command matching stops that fine.

The real cost is usually the inventory, not the config. Most platform teams do not yet have a list of which MCP servers their developers are running, and the allowlist gives them no discovery mechanism. You have to build that list first, from client configs, from the agentic audit log events GitHub exposes, or by asking.

GitHub says the registry method is not a hard boundary

This is the distinction most coverage of the 6 August release missed. The MCP private registry enforcement reference lists two limitations, and as of 11 November 2026 it applies them to the registry-based restriction, not to the managed-settings keys:

"Enforcement is based only on server name/ID matching, which can be bypassed by editing configuration files."

"Strict enforcement that prevents installation of non-registry servers is not yet available."

The same page now sends anyone who needs URL-based enforcement that developers cannot undo on their own machines to the managed-settings allowlist instead.

Read that as written. GitHub's MCP management page now rates the managed-settings file as generally available, with matching on name, URL or command that users cannot override, and the custom registry as a public preview that is not prioritised for development and can be bypassed. If your policy lives in a registry, move it to the file. Turning MCP off in Copilot entirely is still an option for a regulated environment, at a real cost in developer productivity, which is exactly the trade-off a platform team is paid to price.

There is a second control worth pairing with the file-based keys. Under enterprise or organisation settings, "Restrict MCP access to registry servers" offers two options, "Allow all" and "Registry only", against an MCP registry URL you supply. GitHub marks this registry method as a public preview and no longer recommends it for restricting MCP access. If you point it at Azure API Center, enter the base URL including the workspace path, in the form https://SERVICE-NAME.data.REGION.azure-apicenter.ms/workspaces/WORKSPACE-NAME; adding a route suffix such as /v0.1/servers makes the registry error out, because Copilot appends the MCP v0.1 path itself.

For local stdio servers under "Registry only", the server must be in your registry with a server ID that exactly matches the installed server ID. Canonical IDs usually live in the server's documentation or manifest. Getting one character wrong silently blocks a connector your developers expect to work.

Four precedence layers, and which one wins

Enterprise managed settings resolve across four sources. Settings earlier in this list beat settings later:

  1. MDM-managed settings
  1. Server-managed settings
  1. File-based settings
  1. User-level settings

MCP registry policy resolves on a separate axis when a developer holds more than one Copilot seat. GitHub applies a single active policy and registry using three rules, in order: a parent enterprise policy overrides an organisation policy; Registry only beats Allow all because it is more restrictive; and where scope and strictness tie, the most recently uploaded registry wins.

That last rule deserves a note in your runbook. "Most recently uploaded registry wins" means a routine registry refresh in one organisation can change effective policy for contractors who hold seats in two. If you run a multi-org enterprise with shared vendors, set the policy at the enterprise level and stop maintaining org-level registries.

The control you lost on 5 August

VS Code 1.132, released 5 August 2026, removed an admin policy: "The ChatAgentHostEnabled policy is removed, so administrators can no longer centrally disable the agent host through policy. Developers can continue to use chat.agentHost.enabled to choose whether agents run in the separate agent host process."

The agent host is not a minor component. VS Code describes it as a process that "runs agent harnesses such as Copilot, Claude, and Codex in a dedicated process based on the Agent Host Protocol (AHP)." It is the mechanism by which third-party agent harnesses run inside a managed VS Code install. Until 1.132, an enterprise could switch it off centrally. From 1.132, the only remaining lever is a developer-side setting.

So the governance position for August 2026 is asymmetric: the connectors an agent can reach became centrally controllable through a generally available allowlist; the question of which agent harnesses run at all stopped being centrally controllable in VS Code. Teams that built their agent host rollout plan on the 1.129 policy need to re-plan the fleet control, most likely at the extension-install layer or through MDM, which still sits above file-based settings in the precedence order.

One more 1.132 detail with a network dependency: the new multilingual dictation uses an on-device Nemotron 3.5 model that downloads on first use. If your build machines or developer laptops sit behind an egress allowlist, that download fails; VS Code offers a Foundry Local import path as the fallback.

Client coverage: where the allowlist actually applies

Client MCP allowlist enforced Central agent-host disable What to do
GitHub Copilot app Yes, per the 6 August changelog Not applicable Commit the keys and verify on a test seat
Copilot CLI Yes Not applicable Check the CLI config directory for locally added servers
VS Code Yes No, removed in 1.132 Control at the extension or MDM layer instead
JetBrains IDEs Yes, listed in GitHub's client support table by November 2026 Not applicable Commit the keys and verify on a test seat
Copilot in the cloud Yes in cloud sandboxes; not in sessions that run on GitHub Actions Not applicable Check which surfaces still start sessions on Actions
Xcode and Eclipse Not listed as enforced Not applicable Treat as unmanaged for MCP; inventory manually

An allowlist that skips some clients in a polyglot estate is a partial control, and it is worth being blunt about that internally before someone reports it upward as solved. JetBrains IDEs are now covered, but if your iOS teams live in Xcode, the allowlist still does nothing for the engineers who ship your iOS app.

A managed-settings.json you can start from

The enterprise managed settings reference documents the file's shape for the keys that were already supported. As of 11 November 2026 that reference's supported keys table includes permissions.disableBypassPermissionsMode, model, enabledPlugins, extraKnownMarketplaces, strictKnownMarketplaces, telemetry and remoteControl; it now also lists both MCP keys, granular permission rules and a sandbox key. The model key was first documented as permissions.model, and clients still read that nested form. A trimmed version of GitHub's current example configuration is:


            {
  "permissions": {
    "disableBypassPermissionsMode": "disable"
  },
  "model": "auto",
  "enabledPlugins": {
    "my-plugin@agent-skills": true
  },
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "OWNER/REPO" }
  ],
  "telemetry": {
    "enabled": true,
    "endpoint": "https://otel-collector.example.com",
    "protocol": "http/protobuf",
    "captureContent": false,
    "lockCaptureContent": true
  }
}
          

Two settings there do more for your risk position than the MCP keys will. disableBypassPermissionsMode set to "disable" stops users turning on bypass mode, which GitHub also calls YOLO mode, and which lets an agent run commands, access files and fetch URLs without asking for approval. An agent in bypass mode with an approved MCP server is a worse outcome than an agent asking for permission with an unapproved one.

The telemetry block is the other half. With enabled: true, an OpenTelemetry endpoint and lockCaptureContent: true, you get Copilot usage data in a collector you control while preventing users from switching prompt and response capture back on. Deploy that before the allowlist, because it is what tells you which servers are in use in the first place.

In server-managed deployments, any key marked with the { "overridable": <VALUE> } syntax can be replaced per enterprise team. GitHub now lists twelve such keys, among them model and permissions.disableBypassPermissionsMode, plus both MCP keys. A team file can then set "model": "unmanaged" or "disableBypassPermissionsMode": "unmanaged" to take the specialisation, or carry its own MCP allow and deny lists. enabledPlugins and extraKnownMarketplaces behave differently: the first works additively, so a team file adds plugins to the enterprise baseline, while the second is one of the overridable keys. Keys not marked overridable stay an enterprise-level decision. If you are already using that mechanism for team-scoped model policy, the MCP keys sit alongside it without a new deployment path.

Why the vendor shipped this in August

MCP changed underneath everyone in late July. The maintainers finalised the 2026-07-28 revision on 28 July 2026, and Anthropic technical staff member David Soria Parra called it the "most substantial changes we have made to the specification, probably since adding authorization," adding that "a lot of things that made MCP are gone."

The headline change is the removal of protocol-level sessions, so each request is handled independently, with protocol version, client identity and capabilities travelling in the _meta parameter. Routing information is now mirrored in HTTP headers, which lets network equipment route requests without tracking session state or parsing the JSON-RPC body. SEP-2577 deprecated three features, Roots, Sampling and Logging, with suggested migrations: tool parameters or server configuration instead of Roots, direct calls to LLM provider APIs instead of Sampling, and stderr logging for stdio servers or OpenTelemetry instead of Logging. Under the new lifecycle policy all three stay functional for at least 12 months and cannot be removed before the first revision released on or after 28 July 2027, though Stacklok's readiness guide warns that the window is not a guarantee of interoperability: servers on the 2026-07-28 revision may not work with older clients, and the reverse. The maintainers have since moved the next specification release to a March 2027 target, per the notes of their 15 September 2026 meeting; that release falls inside the deprecation window.

Scale explains the governance urgency. When Anthropic donated MCP to the Agentic AI Foundation, a Linux Foundation fund co-founded with Block and OpenAI, the official SDKs were being downloaded more than 97 million times a month across Python and TypeScript, and more than 10,000 public MCP servers were active.

Craig McLuckie, CEO of Stacklok and a co-creator of Kubernetes, framed the stateless move in enterprise terms to The Register: "This gives cyber teams a unified control point to apply agent aware policy and is delivered in a form factor that platform teams are comfortable with running."

A unified control point is the goal. What shipped on 6 August is the first version of it, and GitHub now rates it above its own registry method while it still skips some clients. Both things are true at once, and the protocol choice underneath your agent estate determines how much of this control surface you get at all.

What to do this month

Work in this order. Each step produces something the next one needs.

  1. Turn on Copilot telemetry to an OpenTelemetry collector with lockCaptureContent: true, and pull the agentic audit log events. Without usage data you are writing an allowlist from guesses.
  1. Build the inventory. List every MCP server in use, per client, with its canonical server ID, remote URL or exact local command. Expect the JetBrains and Xcode entries to come from a survey rather than a query.
  1. Set disableBypassPermissionsMode to "disable" before you touch the MCP keys. It is the higher-value control, and once any policy layer sets it to disable, no lower layer can relax it.
  1. Start with deniedMcpServers, not allowedMcpServers. Deny wins, an unset allowlist changes nothing, and an empty allowlist array is a fleet-wide outage. Block the specific servers you have decided against, and watch for a week.
  1. Prefer serverUrl matchers. Use serverCommand where you must, and treat serverName entries as labels rather than controls.
  1. Decide the VS Code agent-host question explicitly now that ChatAgentHostEnabled is gone. If third-party harnesses are out of policy, enforce at the extension-install or MDM layer, which outranks file-based settings.
  1. Write the rollback. managed-settings.json fails closed, so keep a known-good commit and a named owner who can revert it inside your incident SLA.
  1. Re-check in 90 days. GitHub says client support for the managed-settings allowlist is planned to expand, while the registry method stays a public preview that is not prioritised.

India-specific considerations

For teams in India the sequencing question is sharper, because a remote MCP server is a data transfer, not a plugin. Once a Copilot agent can call a connector, prompt content, repository context and whatever the tool returns leave your boundary and reach whichever jurisdiction that server runs in. Under the Digital Personal Data Protection Act 2023, a data fiduciary stays accountable for personal data processed on its behalf, and "a developer installed it" is not a defence.

Three practical consequences follow.

First, serverUrl matchers are the only matcher type that tells you where data goes, which makes them the right default for any Indian entity with residency commitments in customer contracts. A serverName entry tells you nothing about the destination.

Second, the coverage gap matters more here. Because the allowlist skips some clients and a serverName entry is only a label, an allowlist alone is weak evidence of a technical control for an audit. Pair it with egress controls on developer networks and the telemetry export, so you can show what actually ran rather than what policy said should run.

Third, GCC and services teams working for overseas clients frequently hold Copilot seats in more than one enterprise. Under GitHub's multi-seat resolution, the stricter policy and the most recently uploaded registry win, so a client's registry refresh can silently change what your engineers can run. Put registry ownership in the MSA rather than discovering it during a sprint. The wider agent governance layering question and the prompt-injection guardrails that sit under it are both prerequisites, not follow-ups, once connectors reach production systems.

Cost framing before you scope the work

Item Copilot Business Copilot Enterprise
List price per granted seat per month $19 USD $39 USD
200-seat monthly list cost $3,800 $7,800
AI credit allowance Included per plan, metered separately Included per plan, metered separately
MCP allowlist available Yes, set by enterprise owners Yes, via .github-private
Agent-host central disable in VS Code Removed in 1.132 Removed in 1.132

The governance work here is a few days of platform engineering against a subscription line that is already five figures a month for a mid-sized team. That ratio is why the inventory step keeps getting skipped and why it keeps being the expensive one later.

FAQ

How eCorpIT can help

eCorpIT is a Gurugram-based, ISO 27001:2022 certified engineering organisation, and our senior engineering teams work with platform and security groups rolling AI coding agents across mixed IDE estates. We design applications aligned with DPDP requirements, build the connector inventory and telemetry pipeline that makes an MCP allowlist meaningful, and set up the managed-settings deployment path with a tested rollback. If you are deciding how far to lock down agent connectors before your next audit cycle, talk to our engineering team and we will scope it against your actual client mix. Our wider work on enterprise AI agents in production covers the layers that sit underneath this decision.

References

  1. Key Changes in MCP specification 2026-07-28 — Model Context Protocol
  1. Deprecated Features — Model Context Protocol
  1. MCP Core Maintainer Meeting, 15 September 2026, discussion #3402 — modelcontextprotocol on GitHub
  1. Configuring an MCP server allowlist for your enterprise — GitHub Docs
  1. Overriding enterprise-managed settings for enterprise teams — GitHub Docs
  1. MCP allowlists in enterprise managed settings - GitHub Changelog, 6 August 2026
  1. MCP private registry enforcement - GitHub Docs
  1. Restrict MCP server access to a custom registry - GitHub Docs
  1. Enterprise managed settings reference - GitHub Docs
  1. Getting started with enterprise-managed settings - GitHub Docs
  1. MCP server usage in your company - GitHub Docs
  1. Agentic audit log events - GitHub Docs
  1. Visual Studio Code 1.132 release notes, 5 August 2026
  1. Model Context Protocol prepares to break with its stateful past - The Register, 23 July 2026
  1. MCP SDK betas for the 2026-07-28 revision - Model Context Protocol blog
  1. Enterprise Readiness Guide for the July 2026 MCP Spec Update - Stacklok
  1. Donating the Model Context Protocol and establishing the Agentic AI Foundation - Anthropic
  1. Plans for GitHub Copilot - GitHub Docs

Last updated: 11 November 2026.

Frequently asked

Quick answers.

01 What did GitHub release on 6 August 2026?
GitHub made allowedMcpServers and deniedMcpServers generally available in enterprise managed settings. Enterprise owners add the keys to copilot/managed-settings.json in the source organisation's .github-private repository and commit to the default branch, which then controls which MCP servers Copilot clients may run.
02 Does the MCP allowlist actually prevent a developer running a blocked server?
On the clients that enforce it, GitHub describes the managed-settings allowlist as generally available and not overridable by users, provided you match on serverUrl or serverCommand; serverName entries are labels users can change. The bypass by editing configuration files that GitHub documents applies to its older registry-based restriction, which it no longer recommends. Xcode and Eclipse are not covered at all.
03 Which Copilot clients enforce the allowlist?
The 6 August 2026 changelog listed three: the GitHub Copilot app, Copilot CLI and VS Code. By 11 November 2026 GitHub's client support table also lists JetBrains IDEs and Copilot cloud sessions in sandboxes, though not those running on GitHub Actions. Xcode and Eclipse are not listed, so teams working in those editors need a manual connector inventory instead.
04 What happened to the ChatAgentHostEnabled policy?
VS Code 1.132, released 5 August 2026, removed it. Administrators can no longer centrally disable the agent host through policy. Developers can still set chat.agentHost.enabled themselves. The agent host runs harnesses such as Copilot, Claude and Codex in a dedicated process using the Agent Host Protocol.
05 If both allowedMcpServers and deniedMcpServers match a server, what happens?
Deny wins. A server matching deniedMcpServers is blocked even when it also matches allowedMcpServers. An unset allowedMcpServers allows all non-default servers, while an empty array blocks every one of them, so an empty array is a fleet-wide connector outage rather than a safe default.
06 What is the difference between the allowlist keys and the Registry only setting?
The keys are file-based matchers on URL, command or name, committed to .github-private. "Registry only" is an enterprise or organisation setting restricting Copilot to servers published in an MCP registry URL you supply. GitHub lists the keys as generally available and recommended, and the registry method as a public preview with weaker, name-based enforcement.
07 Why did the MCP specification change in July 2026?
The maintainers finalised the 2026-07-28 revision, removing protocol-level sessions so each request is handled independently, with version and capability data carried in the _meta parameter and routing mirrored in HTTP headers. SEP-2577 deprecated Roots, Sampling and Logging, which remain functional for at least 12 months. The maintainers now target March 2027 for the next revision.
08 What should an Indian company do first under DPDP?
Start with telemetry export and a connector inventory, because a remote MCP server moves prompt content and tool output outside your boundary. Prefer serverUrl matchers, which name the destination. Pair the allowlist with network egress controls, since clients outside the allowlist's coverage make policy alone weak audit evidence.

About the author

Manu Shukla

Founder & Director

Founder of eCorpIT. Hands-on engineer leading senior-only delivery for AI apps, custom software, and cloud systems for global clients.

Subscribe

One engineering note a week. No fluff, no spam.

Senior-architect playbooks on AI agents, mobile apps, cloud, security, data, and marketing — delivered every Wednesday.

Past the reading

Read enough. Let's build something.

A senior architect responds in 24 working hours with scope, indicative cost, and a timeline. NDA before any technical conversation.

Loading search…

Browse all guides