Skip to main content
AI Development

Copilot Supabase and Box connectors: check your allowlist

GitHub added eight Copilot connectors, including Supabase and Box. If your MCP allowlist lists connectors one by one, they stay blocked until you add them.

Sean McLellan profile photo

Sean McLellan

Lead Architect & Founder

7 min read
Editorial still life on a pale oak bench against a deep teal wall: a walnut rack with a row of brass plug connectors hanging from pegs, a copper gate bar closed across most of the row and swung open on the left where two plugs hang free, and an open brass padlock on the bench
Constructed diagramIllustration: an open gate lets two connectors through while the rest stay held, standing for an MCP allowlist that decides which Copilot connectors run. Not product UI.

GitHub added eight Copilot connectors on November 18, 2026, including Supabase, Box, Calendly and Buildkite, according to the GitHub changelog. Connectors are GitHub-verified MCP servers that a developer connects by signing in and approving access, and they are in public preview. If your enterprise's MCP allowlist names connectors one URL at a time, the new eight stay blocked until an admin adds them. If it uses GitHub's connector wildcard, they are already allowed unless a deny entry blocks them. Decide which of those you want before developers start clicking Connect.

The new connectors matter more than a typical integration list because of what they can reach. The Supabase connector works "with projects and databases," and Box can "search and manage content." GitHub's connector docs also say Copilot can use a connected service's tools "when they are relevant to your request, even if you do not mention the service by name."

What changed on November 18

The eight new services, as GitHub describes them:

  • Box: search and manage content, and use Box AI
  • Buildkite: work with pipelines and builds
  • Calendly: manage scheduling and meetings
  • ClickUp: track tasks and projects
  • Mixpanel: explore product analytics
  • Supabase: work with projects and databases
  • Webflow: manage sites and content
  • Wix: manage sites and business tools

They join "more than 25 services you can already connect, like Slack, Figma, and Sentry." GitHub's supported connectors list had 34 entries after the release. Developers connect a service once, from the Customize tab in the Copilot app, the Connectors tab under /mcp in Copilot CLI, the Customizations section of the VS Code Agents window, or the Copilot customization page on github.com. GitHub then handles the MCP configuration and authentication.

GitHub gives two examples of the intended use: asking Copilot why the latest Buildkite build failed and fixing the code in the same session, or having it check a Supabase schema before it writes a migration.

Which policies must allow Copilot connectors?

Connectors are available on all Copilot plans. On Copilot Business and Copilot Enterprise, four controls decide whether a developer can use one. GitHub's docs list them:

  1. Editor preview features must be enabled, because connectors are in public preview.
  2. MCP servers in Copilot must be enabled. With MCP servers disabled, connectors don't work.
  3. Restrict MCP access to registry servers must be set to Allow all on clients that enforce it. The Registry only setting blocks connectors.
  4. The MCP allowlist, if your enterprise's managed-settings.json defines one, must include each connector's URL, or a wildcard that matches all of them, on clients that support MCP managed settings.

There is a fifth requirement outside GitHub. Some services need their own admin to allow MCP access. GitHub names Box as one of them, and Slack as another example.

If you rely on the custom MCP registry for control, note GitHub's own comparison in MCP server usage in your company. The registry method is "public preview, not prioritized for development," and it matches servers by name or ID only, which users "can bypass" by editing configuration files. GitHub recommends the managed settings file instead.

Does my MCP allowlist block the new connectors?

It depends on which of three states your managed-settings.json is in. GitHub's allowlist guide describes each one:

Comparison diagram titled What your MCP allowlist does with Copilot connectors. Three cards. No allowedMcpServers list: every connector is allowed unless a deny entry matches; new and future connectors are allowed. One entry per connector URL: only the listed connectors run; new and future connectors are blocked until you add each URL. Wildcard connector entry: all connectors are allowed, including future ones; add deny entries to block specific connectors. A strip below says a matching deniedMcpServers entry always blocks the connector, and an invalid allowlist file blocks every server except built-in defaults.
Constructed diagramConstructed diagram based on GitHub's MCP allowlist and Copilot connectors documentation (November 2026). Not product UI.
  • No allowedMcpServers list. Connectors are allowed unless they match a deniedMcpServers entry. The eight new ones are already allowed.
  • An allowlist with individual connector URLs. Connectors are blocked unless their URL matches an entry. The eight new ones are blocked until you add them.
  • An allowlist with the connector wildcard. All connectors match, "including connectors added in the future." The new ones are already allowed.

Deny rules win in every state. A connector that matches a deniedMcpServers entry is blocked even if the allowlist permits it, and a deny rule from any managed settings source applies.

The example allowlist on the same GitHub page includes https://api.githubcopilot.com/*, but every connector URL in GitHub's table starts with https://api.github.com/copilot-connectors/. That is a different host, so an allowlist copied from the example does not cover connectors by URL. Check your actual file rather than assuming.

Wildcard or one entry per connector: how to choose

This is BaristaLabs guidance, built from GitHub's documented rules.

Use per-connector entries if your security review approves each third-party data source on its own. Supabase and Box reach databases and company files, which deserve their own review, separate from a scheduling tool. Per-connector entries also mean a connector GitHub adds later stays blocked until someone decides on it.

Use the wildcard plus deny entries if you already trust GitHub's verified connector program and want to block only a short list. GitHub documents this pattern: allow all connectors with the wildcard, then add the ones you don't want to deniedMcpServers. The cost is that new connectors arrive allowed by default.

Leave the allowlist undefined only if you intend every MCP server, not just connectors, to run unless denied. That is a broader decision than this release.

For most small and mid-sized teams, BaristaLabs would start with per-connector entries for the services you already use, and add data-heavy ones like Supabase and Box only after deciding which projects and folders Copilot should reach. Each developer connects a service by signing in and approving access, so in our reading, what Copilot can reach follows that developer's account. Scope those accounts before you allow the connector.

How to add the new connector URLs

  1. Confirm the policies. Editor preview features and MCP servers in Copilot are on for the organizations that should use connectors, and registry restriction is set to Allow all.
  2. Open your managed-settings.json. GitHub says most enterprises store it in a .github-private repository; some deploy it to machines with device management. Only enterprise owners can configure the allowlist.
  3. Add a serverUrl entry for each connector you approve. Keep every existing entry, because any MCP server that doesn't match an entry is blocked. For Supabase and Box:
{
  "allowedMcpServers": [
    { "serverUrl": "https://api.github.com/copilot-connectors/api/v1/connectors/githubcopilotsupabasemcp/mcp" },
    { "serverUrl": "https://api.github.com/copilot-connectors/api/v1/connectors/githubcopilotboxmcp/mcp" }
  ]
}

The other six follow the same pattern: githubcopilotbuildkitemcp, githubcopilotcalendlymcp, githubcopilotclickupmcp, githubcopilotmixpanelmcp, githubcopilotwebflowmcp and githubcopilotwixmcp. To allow all connectors instead, use the single wildcard entry https://api.github.com/copilot-connectors/api/v1/connectors/*/mcp.

  1. Validate the file before you rely on it. GitHub's docs say a malformed allowlist, such as invalid JSON, is treated as an empty allowedMcpServers list, which blocks every server except built-in defaults like the GitHub MCP server. Our earlier post on the managed settings validator covers how to catch that. Also avoid unresolved variables such as ${VARIABLE} in URLs, which GitHub says cause the client to block the server.
  2. Enable the service side. For Box, an admin on the Box side has to allow MCP access first.
  3. Test from a supported client. Connect the service from one developer account and confirm it appears. Policy support varies by client, as our JetBrains managed settings pilot post covered for other keys.

Where connectors run, and where they don't

GitHub says connectors work locally and in Copilot sessions on a cloud sandbox, including sessions started on GitHub.com. They are "not yet supported in sessions that run on GitHub Actions, such as when you assign an issue to Copilot." A team that plans to hand issues to Copilot and expects it to read a Supabase schema or a Buildkite log will not get that yet.

Allowlist changes can also lag. If a client can't fetch a policy layer, GitHub says it keeps the previously enforced policy, and the effective policy "can become more restrictive, but not less restrictive." In BaristaLabs' view, that means a newly added connector may stay blocked on a client until it picks up the update, so test after each change rather than assume it took effect.

What this means for engineering leads

The November 18 release lets Copilot connect to your database host, file storage and product analytics. The allowlist is where you decide whether it can, and the result depends on how your file is written. If it lists connectors one by one, nothing new runs until you add it. If it uses the wildcard, all eight are already allowed unless you deny them. For MCP risks beyond connectors, our post on where Docker Sandboxes run MCP servers covers a related boundary. Teams that want help mapping which services Copilot should reach can see our AI consulting approach.

Sources and scope

Connectors are in public preview and GitHub says they are subject to change. This post describes GitHub's documented policies and matching rules. BaristaLabs has not tested how each client enforces them, and it does not cover what each service's own MCP server lets Copilot do once connected.

Copilot connector rollout

Choose which services Copilot can reach before you allow them

Share your current managed settings file and the services your team uses. BaristaLabs can help sort connectors into allow, deny and review-later, write the allowlist entries, and plan a test on one client before the rollout.

Your managed-settings.json and a list of the services you use are enough to start.

Turn this idea into a pilot

Which workflow should go first?

Use the readiness check to compare impact, effort, risk, owner, and next step before requesting a review.

  • 3-5 minutes
  • Deterministic score
  • No sensitive data
Check workflow readiness

Practical AI Workflow Notes

Want more practical AI operations ideas?

Get short notes on applying AI inside real small-business workflows — from document handling and customer follow-up to internal reporting, compliance, and automation guardrails.

A useful next step if you’re still exploring and not ready to request a 20-minute workflow assessment.

Occasional emails. Practical workflow guidance only. Unsubscribe anytime.