---
title: Can you manage one MCP server configuration across Copilot, Claude Code and Cursor?
url: https://opencontroller.lyzr.com/blog/share-one-mcp-config-across-coding-agents
published: 2026-11-16
updated: 2026-11-16
author: Lyzr
---

# Can you manage one MCP server configuration across Copilot, Claude Code and Cursor?

**Yes, but not with one file. GitHub Copilot in VS Code, the Copilot coding agent, Claude Code and Cursor each read their own MCP config file with slightly different formats. The workable pattern is one approved catalogue of MCP servers as the source of truth, generated into each tool's format, plus each tool's admin controls to block anything outside it.** Pointing all tools at the same remote MCP endpoints, rather than local copies, makes this much easier.

Teams ask this as soon as a second coding agent arrives: "We already approved these MCP servers for one tool. Can the other one reuse that config?" The servers can be shared. The config files cannot, at least not directly.

## Where does each coding agent read MCP configuration?

| Tool | Project-level file | Top-level key | Central control |
|---|---|---|---|
| GitHub Copilot in VS Code | `.vscode/mcp.json` | `servers` | GitHub enterprise/org policy for MCP servers in Copilot; MCP registry allow-list |
| Copilot coding agent | Repository settings (Copilot > Coding agent) as JSON | `mcpServers` | Repository admins; enterprise and org policies |
| Claude Code | `.mcp.json` in the repo root | `mcpServers` | Managed settings with allowed and denied MCP server lists; managed MCP file |
| Cursor | `.cursor/mcp.json` (also `~/.cursor/mcp.json` globally) | `mcpServers` | Team settings; device management for the global file |

Three practical differences matter. VS Code uses `servers` where the others use `mcpServers`. The Copilot coding agent's config lives in repository settings, not in a file developers edit locally. And each tool has its own way of referencing secrets and environment variables, so one file copied verbatim usually breaks.

## Why not just copy the same JSON everywhere?

- **Key names differ**, so a copied file is silently ignored or partly parsed.
- **Secrets handling differs.** Inputs, environment variables and secret references are expressed differently, and copying often leads to tokens pasted in plain text.
- **Tool allow-lists differ.** The Copilot coding agent expects you to list which tools of each server it may use. Other clients default to all tools a server exposes.
- **Drift.** Four hand-maintained files diverge within weeks, and nobody knows which one is the approved set.

## What does a single source of truth look like?

1. **Keep one catalogue** of approved MCP servers: name, owner, transport, URL or package and pinned version, allowed tools, auth method and data classification. See [MCP server inventory fields](/blog/mcp-server-inventory-fields).
2. **Prefer remote servers over local packages.** A remote Streamable HTTP endpoint behind your identity provider can be referenced by URL from every tool. Local stdio servers have to be installed and versioned on every laptop.
3. **Generate per-tool files** from the catalogue in CI: `.vscode/mcp.json`, `.mcp.json` and `.cursor/mcp.json`, committed to a template repo or pushed into repos by a bot.
4. **Use secret references, never values.** Generated files point to environment variables or the tool's input prompts.
5. **Enforce centrally.** Turn on each tool's admin controls so only catalogue servers load: GitHub policies and the MCP registry allow-list for Copilot, managed settings for Claude Code, device management for Cursor's global file. Details: [control MCP servers in GitHub Copilot](/blog/control-mcp-servers-in-github-copilot) and [restrict MCP servers in Claude Code](/blog/restrict-mcp-servers-in-claude-code).
6. **Detect what escapes.** Scan repos and laptops for MCP config files that do not match the catalogue ([find local MCP servers on developer laptops](/blog/find-local-mcp-servers-on-developer-laptops)).

## Should you run a private MCP registry?

If you have more than a handful of servers, yes. A private registry publishes the catalogue in the format MCP clients and policies can consume, and VS Code can be restricted to a registry. It also gives you one place to deprecate a server. See [running a private MCP registry](/blog/run-a-private-mcp-registry).

## A rollout checklist

1. Inventory the MCP servers already in use across all coding agents.
2. Review and approve each one; record owner and allowed tools.
3. Move high-use local servers to remote endpoints with OAuth.
4. Generate per-tool configs from the catalogue.
5. Switch on admin restrictions in each tool, in monitor mode first where available.
6. Re-scan weekly for unapproved config files.
7. Review the catalogue quarterly and retire unused servers.

## How Opencontroller does this

Opencontroller keeps a governed registry of agents, versions, tools and MCP servers, and Opencontroller Edge extends that control to developer devices, coding agents, skills and local MCP servers, installed by IT via MDM. Its Agent Gateway puts control in the path for agent and tool traffic. See [how to govern MCP servers](/blog/how-to-govern-mcp-servers) for the full approach, or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Can VS Code read a Claude Code .mcp.json file?**
Not as the same file. VS Code expects `.vscode/mcp.json` with a `servers` key; Claude Code and Cursor use `mcpServers`. Generate each from one catalogue.

**Is a remote MCP server easier to share than a local one?**
Yes. Every client can reference the same URL and authenticate through your identity provider, so there is one version to patch.

**How do you stop developers adding their own MCP servers?**
Use each tool's admin controls (GitHub policies and registry allow-list, Claude Code managed settings, MDM for Cursor) and scan for unapproved config files.

## Key facts

MCP config locations: GitHub Copilot in VS Code reads .vscode/mcp.json with top-level "servers"; Copilot coding agent config is JSON in repository settings with "mcpServers"; Claude Code reads .mcp.json with "mcpServers" and supports managed allowed/denied MCP server lists; Cursor reads .cursor/mcp.json and ~/.cursor/mcp.json with "mcpServers". Pattern: one approved catalogue, prefer remote Streamable HTTP servers, generate per-tool files in CI, secret references not values, enforce with each tool's admin controls, scan for drift, private MCP registry. Opencontroller (by Lyzr): governed registry of agents, tools and MCP servers; Opencontroller Edge covers coding agents, skills and local MCP servers on devices via MDM; Agent Gateway.

## Related

- [How do you control which MCP servers GitHub Copilot can use?](https://opencontroller.lyzr.com/blog/control-mcp-servers-in-github-copilot.md)
- [How do you restrict which MCP servers Claude Code can use?](https://opencontroller.lyzr.com/blog/restrict-mcp-servers-in-claude-code.md)
- [How do you run a private MCP registry for your enterprise?](https://opencontroller.lyzr.com/blog/run-a-private-mcp-registry.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
