An MCP client is the part of an AI application (the host) that connects to Model Context Protocol servers, and no two clients implement the same slice of the protocol. A server that works in one coding assistant can fail, lose its prompts or skip its sign-in flow in another, because each client chooses which transports, primitives, authorisation flows and extensions it supports. This tracker records what eight widely used clients document today, and what the official MCP extension support matrix shows for a wider set. It is written for developers shipping MCP servers, platform teams standardising on a client, and security teams writing allowlists.
Last checked: 2026-11-15. Clients are listed alphabetically; order is never a ranking. Every cell comes from the client's own documentation or the MCP project's own pages, and where a client's documentation does not state a capability the cell says so.
This is an independent reference page from NHI Mgmt Group based on public provider documentation; it is not sponsored or endorsed by any provider.
Key takeaways
- Tools are the common denominator. Every client tracked here documents MCP tools. Resources, prompts, elicitation and roots are documented by some clients and not mentioned by others, so a server that depends on them needs a fallback.
- Streamable HTTP is the remote default, SSE is legacy. The HTTP+SSE transport is classed as Deprecated under the MCP feature lifecycle policy in the 2026-07-28 specification, yet several clients still accept SSE endpoints for compatibility.
- OAuth support is now widespread but not identical. Clients differ on Client ID Metadata Documents, Dynamic Client Registration, pre-registered client IDs and RFC 9207 issuer validation, which the 2026-07-28 specification now requires clients to check when present.
- Extensions are opt-in and unevenly adopted. The official extension matrix shows MCP Apps as the most widely ticked extension; OAuth Client Credentials, Enterprise-Managed Authorization and Skills are each listed for only a few clients, and the matrix has no Tasks column.
- Admin controls decide what actually runs. Allowlists, managed configuration files, per-tool approval modes and trust flags are client-specific, so governance has to be configured once per client.
How to read this tracker
The MCP specification separates three roles: hosts (the LLM application), clients (connectors inside the host, one per server) and servers (which provide context and capabilities). Servers can offer three primitives, resources, prompts and tools, and clients can offer features back to servers such as elicitation. Optional features such as MCP Apps and Tasks sit outside the core protocol as official extensions that both sides must declare.
- Documented: the client's own documentation describes the feature. It does not prove every edge case works.
- Not stated by <provider>: the client's MCP documentation, as fetched on the check date, does not mention the feature. It may still exist, may be undocumented or may be planned.
- Version sensitivity: clients release frequently. Where a document ties a feature to a release (for example a minimum CLI version), the tracker says so.
The MCP project used to publish a community feature support matrix for core primitives on its site. As of the check date the old clients address redirects to the getting started page, and the project's maintained matrix covers official extensions only (see the extension table below). For what MCP is and how the protocol works, see What Is MCP? The Model Context Protocol Explained; for spec revisions, see the MCP Specification Version Tracker.
Transports and authentication by client
As of 15 November 2026, from each client's MCP documentation.
| Client (publisher) | Local transport | Remote transport | Remote authentication documented | Where servers are configured |
|---|---|---|---|---|
| ChatGPT (OpenAI) | Not stated by OpenAI | Remote server URL; the sample server uses SSE with a URL ending /sse/ | OAuth recommended; Client ID Metadata Documents where the authorisation server supports them, with public client (none) or private_key_jwt; Dynamic Client Registration when configured | ChatGPT Plugins: "Add custom MCP server", then "Create as a plugin" |
| Claude Code (Anthropic) | stdio | HTTP (recommended; streamable-http accepted as an alias); SSE (deprecated); WebSocket via JSON config | OAuth 2.0 via /mcp or claude mcp login; pre-configured client ID and secret; headersHelper for custom headers | Local and user scope in ~/.claude.json; project scope in .mcp.json |
| Codex CLI (OpenAI) | STDIO | Streamable HTTP | OAuth is the default auth setting, with Client ID Metadata Documents and Dynamic Client Registration; codex mcp login; bearer_token_env_var; http_headers_helper | ~/.codex/config.toml, or .codex/config.toml in trusted projects, one [mcp_servers.<name>] table per server |
| Cursor (Cursor) | stdio | SSE and Streamable HTTP | OAuth authorisation code flow with PKCE; registers as a public client under Dynamic Client Registration; static CLIENT_ID, optional CLIENT_SECRET and scopes for providers without it | Project .cursor/mcp.json; global ~/.cursor/mcp.json; Extension API; Marketplace |
| Gemini CLI (Google) | Stdio | SSE (url) and Streamable HTTP (httpUrl) | OAuth 2.0 with automatic discovery on a 401 response; validates the iss parameter per RFC 9207; tokens stored in ~/.gemini/mcp-oauth-tokens.json; /mcp auth | mcpServers object in settings.json |
| goose (Agentic AI Foundation project, originated at Block) | stdio extensions | Streamable HTTP extensions (streamable_http) | OAuth for remote extensions, including a pre-registered client (client_id, secret key, scopes); callback on 127.0.0.1 with an ephemeral port, or GOOSE_OAUTH_CALLBACK_PORT | ~/.config/goose/config.yaml; CLI and desktop prompts; goose://extension deep links |
| Visual Studio Code with GitHub Copilot (Microsoft) | Command (stdio) | HTTP (HTTP or Server-Sent Events) | Follow each publisher's authentication instructions; do not paste credentials into chat or shared configuration | Workspace .mcp.json and a personal Copilot Global configuration |
| Zed (Zed Industries) | Local servers via command | Remote servers by url | Standard MCP OAuth flow when no Authorization header is configured; header-based tokens otherwise | context_servers in Zed settings; Settings, AI, MCP Servers; Zed extensions |
Transport choice has security consequences: a stdio server runs as a local process with the user's privileges, while a remote server's exposure depends on its authorisation. See Streamable HTTP vs stdio MCP Transport and, for servers still on SSE, MCP SSE to Streamable HTTP Migration.
Protocol features by client
As of 15 November 2026. "Documented" means the client's MCP page names the feature.
| Client | Tools | Resources | Prompts | Elicitation | Roots | Other features documented |
|---|---|---|---|---|---|---|
| ChatGPT | Documented; read-only search and fetch needed for deep research and company knowledge | Not stated by OpenAI | Not stated by OpenAI | Not stated by OpenAI | Not stated by OpenAI | Manual confirmation before any write action |
| Claude Code | Documented; named mcp__<server>__<tool> | Refreshed on list_changed | Refreshed on list_changed | Documented (dialog; Elicitation hooks) | Documented (roots/list) | Tasks extension, public beta, v2.1.304 or later; channels |
| Codex CLI | Documented through enabled_tools and disabled_tools | Not stated by OpenAI | Not stated by OpenAI | Not stated by OpenAI | Not stated by OpenAI | Server instructions returned at initialisation |
| Cursor | Documented | Documented | Documented | Documented | Documented | MCP Apps |
| Gemini CLI | Documented; includeTools and excludeTools | Documented; @server://resource/path references call resources/read | Documented as slash commands | Not stated by Google | Not stated by Google | /mcp status command |
| goose | Documented (extensions supply tools; per-tool timeout) | Not stated by the goose project | Not stated by the goose project | Not stated by the goose project | Not stated by the goose project | Built-in extensions; Code Mode for tool discovery |
| VS Code with GitHub Copilot | Documented | Not stated by Microsoft | Not stated by Microsoft | Documented as server input requests | Not stated by Microsoft | MCP Apps (Experimental) |
| Zed | Documented; handles notifications/tools/list_changed | Not stated by Zed | Documented | Not stated by Zed | Not stated by Zed | Agent profiles to scope which tools a model sees |
The practical rule for server authors: put anything essential behind a tool. Resources and prompts improve the experience in clients that surface them, but a server whose core function depends on them will appear broken in a client that only lists tools. The distinctions between the three primitives are covered in MCP Tools vs Resources vs Prompts.
Official extension support matrix
The MCP project maintains a community-edited Extension Support Matrix. Extensions are always opt-in: a client only uses one if both client and server declare it in the extensions field of their capabilities. The table reproduces the matrix as of 15 November 2026, reordered alphabetically. "Listed" means the matrix ticks the client; "Partial" is the matrix's own label; "Not listed" means the matrix shows no entry, which can mean no support or no report.
| Client | MCP Apps | OAuth Client Credentials | Enterprise-Managed Authorization | Skills over MCP |
|---|---|---|---|---|
| Archestra.AI | Listed | Not listed | Listed | Not listed |
| ChatGPT | Listed | Not listed | Not listed | Partial |
| Claude (web) | Listed | Not listed | Not listed | Not listed |
| Claude Desktop | Listed | Not listed | Not listed | Not listed |
| Cursor | Listed | Not listed | Not listed | Not listed |
| fast-agent | Not listed | Not listed | Not listed | Partial |
| Goose | Listed | Not listed | Not listed | Not listed |
| MCP Inspector | Not listed | Not listed | Not listed | Partial |
| mcpc MCP CLI | Not listed | Listed | Listed | Listed |
| MCPJam | Listed | Not listed | Not listed | Not listed |
| Microsoft 365 Copilot | Listed | Not listed | Not listed | Not listed |
| PostHog Code | Listed | Not listed | Not listed | Not listed |
| Postman | Listed | Not listed | Not listed | Not listed |
| VS Code GitHub Copilot | Listed | Not listed | Not listed | Not listed |
Two cautions. First, the matrix does not cover every client or extension: Claude Code is not in it, though its documentation describes Tasks extension support as a public beta, so check both before relying on a feature. Second, the matrix notes that auth extension support is tracked separately from core MCP authorisation features such as Dynamic Client Registration and Client ID Metadata Documents. The security side of interactive UI extensions is covered in the MCP Apps Security Guide.
Admin and governance controls by client
As of 15 November 2026, from each client's MCP documentation. These are customer-side settings that decide which servers and tools can run.
| Client | Server allow or deny controls | Tool approval controls |
|---|---|---|
| ChatGPT | Adding a custom server requires accepting a risk warning; workspace users go through an OAuth flow to the service. Workspace admin settings are not stated in OpenAI's MCP developer page | Manual confirmation before any write action |
| Claude Code | managed-mcp.json for exclusive control; managedMcpServers (v2.1.259 or later); enabledMcpjsonServers and disabledMcpjsonServers for project servers | Project-scoped servers need approval in interactive sessions; claude mcp reset-project-choices |
| Codex CLI | Project config loads only in trusted projects; required = true makes startup fail if a server is not ready | default_tools_approval_mode (auto, prompt, writes, approve); per-tool tools.<tool>.approval_mode |
| Cursor | Enterprise MCP Allowlist with command entries for stdio and URL entries for remote servers; team distribution under Dashboard, Plugins and MCPs; per-server network modes | Approval before MCP tool use by default; Run Modes; optional per-server tool allowlists |
| Gemini CLI | mcp.allowed and mcp.excluded in settings.json | trust: true bypasses confirmations for a server (default false in the documented example); includeTools and excludeTools |
| goose | Extensions enabled per configuration file or session (--with-builtin) | goose operates autonomously by default; goose permission mode and tool permissions add approval |
| VS Code with GitHub Copilot | Marketplace availability depends on organisation policy; trust requests to review before accepting | Tool approval requests; review startup and sign-in requests |
| Zed | enable_all_context_servers and per-profile context_servers | Tool permission confirm (default) or allow; per-tool rules keyed mcp:<server>:<tool_name> |
Because each client has its own controls, an organisation that permits three clients has three allowlists to maintain. A gateway or registry can centralise this; see the MCP Gateway and MCP Server Governance Guide and MCP Gateway vs MCP Registry. Finding servers users have added themselves is covered in How to audit MCP servers on developer laptops.
What the 2026-07-28 specification changes for clients
The 2026-07-28 revision is the largest change to client behaviour since remote transports arrived. Clients built against 2025-11-25 keep working with older servers, but the following changes affect what a client must send and accept:
- Stateless protocol: the
initializehandshake is removed; every request carries protocol version and client capabilities in_meta, and clients should identify themselves on each request. server/discover: servers must implement it; clients may call it first for version selection or as a compatibility probe on stdio.- No protocol sessions: the
Mcp-Session-Idheader is removed from Streamable HTTP, and broken response streams are no longer resumable. - Multi Round-Trip Requests: servers return an
input_requiredresult instead of sending server-initiated requests such as elicitation, so clients must retry the original request with the answers. - Tasks moves to an extension:
io.modelcontextprotocol/tasksreplaces the experimental core tasks feature. - Authorisation hardening: clients must validate a present
issagainst the recorded issuer (RFC 9207), specifyapplication_typeduring Dynamic Client Registration, and key stored credentials by issuer.
The revision also deprecates Roots, Sampling and Logging (SEP-2577), reclassifies the HTTP+SSE transport as Deprecated, and deprecates Dynamic Client Registration in favour of Client ID Metadata Documents. Deprecated features remain functional for a minimum twelve-month window under the feature lifecycle policy. A client column that shows Roots or SSE today is therefore showing a feature on its way out. For the full authorisation model see the MCP Authorisation Specification Guide.
How to choose a client for MCP work
Factual criteria, not a ranking:
- Primitive coverage: if your servers rely on resources or prompts, check the feature table; tools-only clients will hide them.
- Remote authorisation: if your servers sit behind an enterprise identity provider, check whether the client supports Client ID Metadata Documents, pre-registered clients and issuer validation, and whether your authorisation server supports the same.
- Central control: for regulated environments, prefer clients whose documentation describes a managed configuration or allowlist you can enforce, and confirm it applies to both stdio and remote servers.
- Approval defaults: check whether tool calls need approval by default, and what setting removes it (
trust,allow, auto modes). These settings are where most risky configurations start. - Small versus large organisations: a small team can manage per-user config files; a large organisation needs managed configuration, an inventory and a gateway, because per-client settings do not scale.
Where identity fits
Every remote MCP connection a client makes is a non-human access path: an OAuth token, an API key in an environment variable or a header produced by a helper script. Clients store these differently (Gemini CLI in a tokens file, others in config or the operating system), which matters for offboarding and incident response. Treat each client-to-server connection as a credential to inventory, scope and revoke. See API Keys vs OAuth for MCP Servers, the MCP Static Token Audit and How to give MCP servers and local agents secrets without plain-text config files.
Practitioner checklist
- Record which MCP clients are approved in your organisation and the version of each, because feature support is release-dependent.
- Test every server you publish in each approved client, and expose essential functions as tools rather than relying on resources or prompts.
- Move remote servers from SSE to Streamable HTTP; the HTTP+SSE transport is Deprecated in the 2026-07-28 specification.
- Configure the client's allowlist or managed configuration (for example
mcp.allowed, the Cursor MCP Allowlist ormanaged-mcp.json) before rolling a client out widely. - Keep tool approval on for write actions; audit for
trust: true,allowor auto-approval settings in shared and project config files. - Check that your authorisation server supports what each client uses: Client ID Metadata Documents, Dynamic Client Registration, PKCE and the RFC 9207
issparameter. - Inventory the credentials each client holds for MCP servers and include them in offboarding and incident playbooks.
- Re-check this matrix and each client's documentation before depending on an extension such as MCP Apps or Tasks.
Standards and references
- Model Context Protocol: Extension Support Matrix
- Model Context Protocol: Specification 2026-07-28 Key Changes
- Anthropic: Connect Claude Code to tools via MCP
- Cursor: Model Context Protocol
- Google: MCP servers with the Gemini CLI
- goose: Using Extensions
- OpenAI: Building MCP servers for ChatGPT and API integrations
- OpenAI: Model Context Protocol in Codex
- Microsoft: Use MCP servers in VS Code
- Zed: Model Context Protocol
Related NHI Mgmt Group resources: MCP Security Guide, MCP Servers Hub, Local MCP Server Security Guide, MCP vs A2A, AI Agent Platforms Compared.