The host is the end-user AI application (Claude Desktop, Cursor, Claude Code, Zed, Continue) that owns the user interface, calls the LLM, and orchestrates the agent loop. It contains one or more MCP clients, each a library-level object maintaining a single connection to one server. The host decides which servers to connect to, merges their tool catalogs, handles user consent, and routes tool calls. The client handles JSON-RPC plumbing for one server connection. Containment: host contains clients; each client connects to one server.
**An MCP host** is the AI application a user opens on their machine. Claude Desktop, Cursor, Zed, Claude Code, and Continue are all hosts. The host is the only MCP role that has a user-facing interface.
The key distinction is between host and client. The client is a small library inside the host that handles the JSON-RPC protocol for one server connection. The host is the entire application: the window or terminal, the chat thread, the configuration UI, the code that calls the LLM, and the orchestration logic that drives the agent loop.
A host contains zero or more clients. Each client maintains exactly one connection to one server. You can have a host with no clients (no MCP servers configured) and it is still a host; it just is not using MCP yet. You cannot have a client without a host because the client is a library that must be embedded in something.
The host's responsibilities go well beyond protocol mechanics. It decides which servers to connect to, prompts the user for consent before connecting to remote servers, merges tool catalogs from all connected clients into a single catalog for the LLM, calls the inference API, parses the model's tool calls, routes each call to the correct client, and renders everything in the UI.
Mnemonic: host = app the user opens, client = library inside that app, server = external capability provider.
**An MCP host** is the end-user AI application that calls the LLM, owns the user interface, and orchestrates one or more MCP clients to expose external capabilities to the model. Each client is a library-level object inside the host, maintaining a single connection to one server.
The host's responsibilities are everything outside the protocol boundary. Configuration: which servers the user has added and how to launch or connect to them. Consent: prompting the user before connecting to remote servers or executing destructive tool calls. Catalog merging: combining tool lists from all clients into the single catalog advertised to the model through the provider's function-calling API. Model orchestration: calling the inference API, parsing function calls, and driving the agent loop with stopping conditions. Routing: forwarding each tool call to the correct client. UI rendering: displaying the chat, tool-call transcripts, slash-command menus from prompt templates, and resource previews.
The client is intentionally thin. It lives inside the host process, speaks JSON-RPC 2.0 on the wire, handles the initialize handshake, serializes requests and responses, and manages disconnect. It does not own a UI, does not call the LLM, and does not decide which tools to expose. A host with five configured servers has five client objects, all doing the same minimal protocol work, while the host orchestrates the user experience around them.
The 2026 host landscape includes Claude Desktop, Cursor, Zed, Continue, Sourcegraph Cody, Windsurf, Claude Code, OpenAI Agents SDK, and Google Gemini CLI. The protocol stops at the client intentionally: each vendor builds the host experience they want while sharing the integration substrate underneath.
Quick reference
TL;DR
The host is the user-facing AI app (Claude Desktop, Cursor) that calls the LLM and orchestrates the agent loop. The client is a library inside the host, one per server connection.
If MCP is a city of services, the host is the building the user walks into. Inside that building are several phones (clients), each wired to a different outside helper (servers). The building has a front desk, lights, and a kitchen that talks to the AI brain (the LLM). The user never picks up the phones directly; they ask the front desk and the building decides which phone to use. Claude Desktop, Cursor, Claude Code, Zed, and Continue are all examples of these buildings.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
A backend job that needs to invoke MCP tools without any user interaction. Hosts assume a user is in the loop for consent and UI. A headless pipeline typically wires up an SDK client directly and skips the host pattern.
A tool integration with no LLM in the loop at all. The host role exists to feed the model. Without a model, the MCP host layer adds protocol overhead for no benefit; a direct API call is simpler.
An embedded device with no interface for consent flows or chat rendering. Host responsibilities like consent, catalog rendering, and chat UI require a real user interface. Headless devices either need a minimal host shell or a different integration model.
Quick scan · 2–4 min
Everything important, quickly.
5 min: state the one-sentence definition, give the host > client > server containment mnemonic, name five concrete hosts, walk through three host responsibilities beyond protocol mechanics, and explain why the protocol intentionally stops at the client.
Real-world examples
Real products, models, and research that use this idea.
1Claude Desktop is Anthropic's desktop AI app and the original MCP host, shipped alongside the protocol launch in November 2024.
2Cursor is a popular AI-first code editor that embeds MCP clients and supports both local stdio and remote HTTP servers for tool integrations.
3Claude Code is Anthropic's CLI coding agent, serving the same MCP host role as Claude Desktop but in a terminal interface.
4OpenAI Agents SDK and Google Gemini CLI are non-Anthropic hosts that adopted MCP in 2025 and 2026, proving the protocol is vendor-neutral in practice.
5Zed is a fast multi-pane editor with native MCP support, connecting to the same community servers that Claude Desktop and Cursor use.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QCan two hosts share the same MCP server, and if so, what does each see?
Sign in or go Pro to see the approach for this follow-up.
QWhere does the LLM actually run relative to the host?
Sign in or go Pro to see the approach for this follow-up.
QWhy does MCP stop at the client instead of standardizing the host experience?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Confusing host with client. The host is the AI app the user opens (Claude Desktop, Cursor). The client is a library inside that app, instantiated once per connected server.