Control GitHub Copilot Customizations with Enterprise Managed Settings
Coding-agent adoption creates a less obvious problem than model quality: developers can obtain instructions and tools from several places. A repository can contain a project-wide instruction file, a developer can install a personal MCP server, and an IDE or CLI can load a skill or executable extension. Those sources are useful, but they can also become an unreviewed supply chain.
GitHub's November 16, 2026 customization controls address that boundary. Enterprise administrators can require selected Copilot customizations to come from eligible plugins or managed settings instead of standalone user or project configuration. Marketplace controls can then determine where approved plugins come from.
This is an enterprise governance feature, not a replacement for code review or MCP server security. Used carefully, however, it gives an organization a practical way to keep approved tools available while stopping arbitrary standalone configuration.
Customizations are more than prompts
It is tempting to describe a coding agent's customizations only as prompts. Repository instructions affect how an agent understands a project, but current Copilot surfaces can also expose:
- custom agents;
- skills;
- hooks;
- MCP servers;
- and executable Copilot extensions, including executable canvas providers.
An MCP server can provide real tools and data access. A hook or executable extension can run actions outside a normal chat response. Their trust properties therefore differ from a paragraph of project guidance.
That distinction matters during policy design. Blocking every custom instruction may prevent unsafe paths, but it can also remove valuable repository context. Blocking every tool may reduce exposure, but it can stop developers from using the integrations they need. GitHub's category-specific controls let an administrator narrow the policy instead of making one all-or-nothing choice.
A short note on availability and precedence
The November 16 announcement applies to enterprise-managed settings for GitHub Enterprise Cloud members who have Copilot Business or Copilot Enterprise licenses issued by the enterprise or one of its organizations. Teams should verify plan, tenant, client, and session support before relying on enforcement.
The relevant setting is strictPluginOnlyCustomization. It can restrict all supported categories, or it can name only selected categories:
skillscustom agentshooksmcpextensions
Managed settings have precedence over repository defaults and member preferences. That precedence is useful, but it does not make every plugin or marketplace safe. The organization still has to review code and apply appropriate server, authentication, and sandbox policies.
The four controls to understand
GitHub's managed-settings model separates distribution, source restrictions, plugin requirements, and standalone customization restrictions.
1. extraKnownMarketplaces
Use extraKnownMarketplaces to make an additional plugin marketplace available to enterprise members. A GitHub repository can provide the marketplace definition:
{
"extraKnownMarketplaces": {
"engineering-tools": {
"source": {
"source": "github",
"repo": "ORG/REPOSITORY"
}
}
}
}
The marketplace name must match the name in its marketplace.json. Members need repository read access, and private marketplaces need to be hosted where their intended users can access them.
Adding a marketplace is not an allowlist. It makes plugins available; it does not by itself prevent users from configuring standalone tools.
2. strictKnownMarketplaces
Use strictKnownMarketplaces when approved source repositories must be the only eligible marketplace sources:
{
"strictKnownMarketplaces": [
{
"source": "github",
"repo": "ORG/REPOSITORY"
}
]
}
This setting restricts eligible marketplace sources and disables built-in marketplaces. It is therefore an important distinction: plugin-only policy controls which customization category comes from a plugin or managed settings, while marketplace policy controls which repositories can supply those plugins.
Do not assume the names are interchangeable. A plugin-only policy without a marketplace allowlist can still permit plugins from eligible sources; an allowed marketplace by itself does not block standalone configuration.
3. enabledPlugins
enabledPlugins requires or blocks named plugins. The identifier combines a stable plugin name with a marketplace name:
{
"enabledPlugins": {
"REQUIRED-PLUGIN@engineering-tools": true,
"BLOCKED-PLUGIN@engineering-tools": false
}
}
Set a plugin to true to require it and false to block it. This is useful for a baseline of organization-approved tooling or for disabling a known plugin. It is also why plugin and marketplace names should be stable and documented.
4. strictPluginOnlyCustomization
Finally, strictPluginOnlyCustomization blocks standalone customizations for selected categories:
{
"strictPluginOnlyCustomization": ["mcp", "extensions"]
}
In this example, MCP servers and executable Copilot extensions must come from eligible plugins or managed settings. Skills, custom agents, and hooks remain unrestricted. To restrict all supported categories, use true.
A team might begin with only ["mcp", "extensions"], where executable tools have the highest direct operational impact. It might restrict skills and agents later after validating the workflow. Broad enforcement should follow an inventory, not precede one.
Combining the controls for approved MCP tooling
The official rollout pattern is straightforward: add an internal marketplace, restrict marketplace sources, optionally require or block plugin identifiers, and block equivalent standalone customizations.
{
"extraKnownMarketplaces": {
"engineering-tools": {
"source": {
"source": "github",
"repo": "ORG/REPOSITORY"
}
}
},
"strictKnownMarketplaces": [
{
"source": "github",
"repo": "ORG/REPOSITORY"
}
],
"enabledPlugins": {
"REQUIRED-PLUGIN@engineering-tools": true,
"BLOCKED-PLUGIN@engineering-tools": false
},
"strictPluginOnlyCustomization": ["mcp", "extensions"]
}
Replace every placeholder and deploy the settings without removing unrelated managed policy. The example JSON was locally syntax-checked, but this article does not claim that a real GitHub tenant accepted or enforced it.
The rollout should begin with an existing, approved MCP server. Package its required configuration and, when useful, related skills in a plugin. Then check positive and negative behavior:
- A member can install or receive the allowed plugin.
- The plugin-provided MCP server is visible and usable.
- An equivalent standalone MCP server is blocked.
- A disallowed marketplace or plugin cannot supply a replacement.
- Required authentication and network rules still operate.
Plugins package MCP configuration. They do not host a remote server or replace its authentication. A plugin can make an approved configuration easier to distribute, while the server still needs endpoint authentication, least privilege, and appropriate network controls.
The policy is not a plugin security review
A marketplace allowlist is useful, but it is not proof that a plugin is safe. GitHub documents explicitly separate distribution controls from plugin safety. An organization should review plugin components, MCP tool definitions, executable behavior, permissions, and dependencies before approving them.
The following questions are especially useful:
- What network destinations can the MCP server reach?
- What repository, credential, or cloud permissions does a plugin need?
- Does a hook or executable extension run shell commands or write files?
- Can a plugin expose secrets or private repository data to a remote service?
- Is the plugin pinned or reviewed, and how are updates handled?
- Can users bypass the control through another supported client or session type?
No managed setting can answer those questions by itself. It only determines whether an organization-authorized source is required for a customization category.
Repository instructions are also source boundaries
Managed plugin restrictions govern many executable capabilities, but instructions remain an important part of agent context. GitHub supports repository-wide instructions in .github/copilot-instructions.md, path-specific instructions under .github/instructions, and agent instructions such as AGENTS.md.
The nearest applicable AGENTS.md is used for agent instructions, and repository-wide plus path-specific instruction files can combine when both match a request. That behavior means repository instructions should be reviewed with the same care as build scripts or automation configuration.
This does not mean every repository should copy the same instruction file. A repository with no MCP integration may need a build and test policy only. A monorepo may need path-specific guidance for package boundaries and validation commands. The point is to treat instruction changes as a reviewable source of agent behavior.
A safe staged rollout checklist
For most organizations, enforcement should be progressive:
- Inventory customization sources. Record local MCP configurations, repository instructions, agent files, plugins, hooks, and executable extensions.
- Identify required clients. Check VS Code, Copilot CLI, GitHub.com sessions, cloud sandboxes, mobile, IDE integrations, and any custom environment the team uses.
- Start with a narrow category. MCP servers or executable extensions are often the clearest first scope.
- Create an approved marketplace repository. Confirm read access for private repositories and document ownership.
- Package existing approved tools. Include MCP configuration and related skills without assuming that the plugin supplies the server itself.
- Require or block named plugins deliberately. Use stable plugin and marketplace names.
- Test positive behavior. Confirm that an approved plugin loads in every supported client.
- Test negative behavior. Confirm that an equivalent standalone MCP server or executable extension is blocked.
- Check exceptions. If a team needs a development environment for standalone servers, use a narrowly scoped team override rather than weakening the enterprise policy for everyone.
- Monitor usage and review updates. Plugin metrics and source review help detect drift, but they do not replace periodic access and permission reviews.
GitHub documentation advises verification in every client and session type. A setting that appears to work in a web session may not have an identical effect in an IDE or CLI. Keep unsupported clients on their existing controls until they support the replacement.
Rollout trade-offs
Plugin-only controls improve provenance and reduce accidental standalone configuration, but they add operational work:
- Marketplace maintenance becomes an owned platform service. Plugin package names and source repositories need owners and release checks.
- Developer setup may become more uniform and less immediate. Contributors lose the ability to add a local tool outside the policy.
- MCP remains a separate security concern. Allowing only approved plugin configuration does not prove that the endpoint or credentials are least-privileged.
- Enforcement can vary by surface. The exact behavior depends on client support and session type.
- Broad restrictions can hide required exceptions. Restricting every category at once is more likely to break workflows than a staged change.
These costs are manageable when the organization already maintains an internal tooling catalog. They are expensive if the policy is introduced only to label random personal MCP servers as “approved.” A real approval process and server lifecycle are still necessary.
What QZ-L developers should take from this
For teams building services around short links, QR codes, analytics, or AI assistants, agent customizations should be treated like dependencies: source-controlled, reviewed, and distributed consistently. A repository instruction can guide testing and validation. A plugin can package an approved MCP integration. Managed settings can ensure that a developer's personal server or a standalone extension does not quietly replace the approved one.
The policy should be narrow enough to preserve useful repository context while strict enough to control real tool sources. Start with categories that execute tools or access data, verify every client, and keep plugin code review as a separate gate.