MCP clients for coding agents

An MCP client is the part of an AI application that connects to an MCP server and uses what the server offers. You rarely install one. You pick an agent, such as Claude Code, Codex, Cursor, Gemini CLI, Antigravity, VS Code or OpenCode, and it already contains the client. What differs is how each agent is told about a server. We checked each vendor's docs on 31 October 2026.

Quick facts

Host, client and server: three words, one idea

The MCP docs keep these apart on purpose, and the confusion is common enough to be worth a minute.

The host is the application you sit in front of. Claude Code is a host. So is Cursor. The host decides what you see, which model runs and what needs your approval.

A client is a component the host creates for each server it talks to. If you add three servers, the host runs three clients. Each one keeps a single connection and knows nothing about the others.

A server is the program on the other end. It offers tools, resources and prompts. Some run on your machine, and some are hosted by a vendor at a URL.

So when a page says "this MCP server works with any MCP client", it means any host that includes a compliant client. In daily life people say "client" and mean the agent. We do the same below, and say "protocol client" when we mean the component.

For the server side, see our MCP servers hub.

What clients can offer back to servers

MCP is not one-way. The client concepts page lists three features a client may provide to servers.

Elicitation matters most for hosted servers. URL mode exists so that a sensitive step, such as a payment sign-in, happens in your browser and its data never passes through the client. If a server you use asks you to open a link, that is this feature at work.

Support for these features varies by agent. We did not find a single table that lists which agent implements which, so we do not claim one. Check each agent's MCP docs before you depend on elicitation.

The two transports you will meet

Every client we checked supports both of these.

stdio. The agent starts the server as a child process and talks over standard input and output. It suits tools that need your files or your shell. You supply a command, arguments and sometimes environment variables. The server dies when the agent exits.

Streamable HTTP. The agent connects to a URL. This is how hosted servers work. Authentication is a header you set or an OAuth sign-in the agent runs for you.

There is an older remote transport, SSE. Claude Code's docs call it deprecated and say to use HTTP where available. Gemini CLI still documents a url field for SSE endpoints next to httpUrl for HTTP. Antigravity's docs say the legacy HTTP+SSE transport is not supported. If a vendor only gives you an SSE address, check whether an HTTP one exists before you add it.

How each agent adds a server

The table is the short version. Details follow.

Claude Code

Claude Code has the widest set of options. A remote server:

claude mcp add --transport http notion https://mcp.notion.com/mcp

A local one, with the double dash separating Claude's flags from the server's command:

claude mcp add --transport stdio airtable --env AIRTABLE_API_KEY=YOUR_KEY -- npx -y airtable-mcp-server

Servers live in three scopes: local (private to you in one project), project (a .mcp.json the team shares, which each person must approve) and user (every project). Claude Code also accepts WebSocket servers, with header-only authentication. A url entry without a type is a configuration error, because an entry with no type is read as stdio.

Inside a session, /mcp shows status and handles OAuth sign-in. By default Claude Code uses tool search, so tool definitions load on demand instead of all at once, which keeps big server lists from eating the context window. See our guide to MCP servers in Claude Code.

Codex

Codex stores MCP configuration in config.toml, by default at ~/.codex/config.toml, or per project at .codex/config.toml. It supports stdio and Streamable HTTP, with bearer-token and OAuth authentication.

codex mcp add context7 -- npx -y @upstash/context7-mcp
codex mcp login <server-name>

[mcp_servers.context7]
command = "npx"
args = ["-y", "@upstash/context7-mcp"]

codex mcp login is for servers that support OAuth. The app and TUI also show which servers are enabled and which need sign-in; type /mcp in the composer to see them.

Cursor

Cursor reads mcp.json, in .cursor/ for one project or in your home directory for all of them. The docs list three transport types: stdio, SSE and Streamable HTTP. For remote servers, a url plus optional headers:

{
  "mcpServers": {
    "server-name": {
      "url": "https://example.com/mcp",
      "headers": { "API_KEY": "value" }
    }
  }
}

Cursor supports OAuth, and also static OAuth client credentials in mcp.json for providers that do not offer Dynamic Client Registration. It has a Marketplace with one-click plugin install, and the docs point to cursor.directory for community entries.

Gemini CLI

Gemini CLI uses mcpServers in settings.json. Entries take command for stdio, httpUrl for HTTP streaming or url for SSE, plus headers, timeout (default 600,000 ms per the docs), trust, includeTools and excludeTools.

gemini mcp add --transport http example https://example.com/mcp

The Gemini CLI docs list -s, --scope (user or project, default project), -t, --transport (stdio, sse or http), -H, --header and --trust as the add options. Keep trust false. When true, it bypasses tool confirmations for that server.

One status note we repeat across the site: Gemini CLI is now for Google Code Assist enterprise customers. Individual users moved to Antigravity CLI on 18 June 2026.

Antigravity

Antigravity covers an App, a CLI and an IDE, and all three read the same file format. The global file is ~/.gemini/config/mcp_config.json; a workspace file lives at <workspace>/.agents/mcp_config.json. In the CLI, /mcp opens an interactive manager with live status and logs. In the App and IDE there is an MCP Store you install from.

{
  "mcpServers": {
    "my-remote-server": {
      "serverUrl": "https://api.example.com/mcp/",
      "headers": { "Authorization": "Bearer YOUR_API_TOKEN" },
      "timeoutSeconds": 600
    }
  }
}

Each entry names one transport, command for stdio or serverUrl for remote. The docs also list authProviderType: "google_credentials" to attach Google Application Default Credentials, a manual oauth block for servers without Dynamic Client Registration, and a disabled flag.

VS Code

VS Code's .vscode/mcp.json uses a top-level servers key, not mcpServers. This is the most common reason a pasted config does nothing. VS Code also has a command line form: code --add-mcp '{"name":"...","command":"...","args":[...]}'.

OpenCode

OpenCode puts servers under mcp in opencode.json. A local entry has "type": "local" and a command array. A remote one has "type": "remote", a url, optional headers and an oauth block. It handles OAuth automatically: on a 401 it starts the flow and uses Dynamic Client Registration if the server supports it. Requests time out after 30 seconds by default. The docs warn that MCP servers add to your context, and name the GitHub server as one that can add enough tokens to exceed the limit.

Moving one server between agents

Say you have a working server in Claude Code and want it in Cursor and Antigravity. The work is mostly renaming.

1. Find the transport. Is it a command or a URL?
2. Pick the file from the table above.
3. Rename the fields. A remote url in Cursor becomes serverUrl in Antigravity and httpUrl in Gemini CLI. In VS Code the parent key changes to servers.
4. Re-run sign-in. OAuth tokens are stored per agent. A login in one does not carry to another.
5. Restart the session and list tools with the agent's own command.

Many vendors publish a one-click link or a per-agent snippet. Where they do, use that, because they are tested. Where they do not, say so to your team: the line you wrote is an adaptation.

Approval, trust and what a client protects you from

A protocol client does not make a server safe. What protects you is the host's approval model.

• Per-call approval. Most hosts ask before a tool runs, with an option to always allow. Always-allow on a server that writes or deletes is a decision, not a convenience.
• Allow and deny lists. Gemini CLI has includeTools and excludeTools per server. Codex documents tool filters in its config. Claude Code has permission rules and managed policy lists for organizations.
• Project config approval. Claude Code asks each person to approve a server from a shared .mcp.json. That matters, because a cloned repo can otherwise name a server for you.
• Secrets. Prefer environment variable expansion or the agent's own secret handling to pasting tokens into a file you commit.

The content a server returns is untrusted input. A web page, a ticket or a file read through a tool can carry text aimed at the model. This is prompt injection, and no client fully removes it. Keep read-only modes on for anything pointed at production data, and keep the number of connected servers small.

Cost: tools consume context

Every connected server adds tool definitions. Ten servers with thirty tools each is a lot of text before you type a word. Clients handle this differently. Claude Code defaults to tool search, loading definitions on demand. OpenCode's docs simply tell you to be selective. A good habit: connect what the current project needs and switch off the rest. We cover which servers earn a permanent slot in best MCP servers.

Which agent suits which person

This is a reading of the docs, not a hands-on ranking.

Our take

We did not run a compatibility test for this page. This is built from the vendors' own documentation.

The headline is that "MCP support" is real but not uniform. Every agent here can run a stdio server and a Streamable HTTP server, which covers nearly all published servers. The friction is in the details: file names, the top-level key, the remote URL field, and whether sign-in is automatic. Those are small, but they are what breaks a copy and paste.

Two practical rules follow. First, treat each vendor's line for a server as the source of truth for that agent, and treat anything else as an adaptation to check. Second, keep one canonical record of your servers, even a short note, so moving between agents is a matter of renaming fields rather than rediscovering what you installed.

The deprecation of sampling and roots in the latest protocol version is also worth noticing. Servers that relied on sampling to avoid holding a model key may need another route. We did not find a vendor statement on how each agent handles that change, so check each agent's changelog.

Setup checklist

1. Decide stdio or remote for the server you want.
2. Open that agent's section above and copy the file path.
3. Write the entry, with secrets in environment variables.
4. Restart the session.
5. List tools with /mcp (Claude Code, Codex, Antigravity CLI) or the settings page.
6. Run one read-only call first.
7. Turn on always-allow only for tools you have read.

Related pages

• MCP servers hub for what to install.
• Playwright MCP is a good first stdio server.
• GitHub MCP shows a hosted server with OAuth.
• Context7 MCP works with every agent above.
• MCP marketplaces for where to find more.

Frequently asked questions

What is an MCP client?

A component inside an AI application that holds one connection to one MCP server. The application is the host and may run several clients at once.

Which AI coding agents support MCP?

Claude Code, Codex, Cursor, Gemini CLI, Antigravity, VS Code with Copilot and OpenCode all document MCP setup. Each has its own config file and field names.

Do all clients support remote HTTP servers?

Every one we checked does. Antigravity accepts only Streamable HTTP for remote servers, and Claude Code treats SSE as deprecated.

Can I share one MCP config across agents?

Only partly. The entries look alike, but the file, the top-level key and some field names differ.

Why does a server work in one agent and not another?

Usually the config shape. A URL entry with no type fails in Claude Code, VS Code wants a servers key and Antigravity wants serverUrl.