API vs CLI vs MCP: How Claude Guides Their Collaboration for Production‑Grade Agents

1. How agents connect to external systems

We typically see three integration paths: direct API calls, CLI, and MCP. The choice depends on whether a shared layer exists between the agent and the service and how broadly that layer is covered.

1.1 Direct API calls

Agents call your API directly—sending HTTP requests from a sandbox or invoking generic functions. This works for one‑to‑one agent‑service integration or limited cross‑platform reuse. At scale, each agent‑service pair becomes an isolated integration (the M×N problem), each handling its own authentication, tool description, and edge cases.

1.2 Command‑line interface (CLI)

Agents run command‑line tools in a shell. It is fast and lightweight, leveraging existing toolchains and works well where a filesystem is available (local environments, sandbox containers). However, CLI access is restricted on mobile, web, or cloud‑hosted platforms that do not expose containers. Authentication is handled by the CLI itself, typically via credential files on disk, making CLI best suited for local, permissive integrations.

1.3 Model Context Protocol (MCP)

MCP implements the shared layer as a protocol. An agent connects to a server that exposes capabilities—authentication, discovery, rich semantics—through a standardized interface. Any compatible client (Claude, ChatGPT, Cursor, VS Code, etc.) can access the server regardless of deployment environment.

Initial investment is higher, but the payoff is portable integration with rich semantics needed for sophisticated agents.

2. Production‑grade agents run in the cloud

Production agents increasingly run in the cloud to scale and stay continuously available. They need to integrate with cloud‑hosted systems (data stores, work trackers, infrastructure). These systems are remote and require authentication—the exact scenario MCP addresses.

Adoption trends are evident: MCP SDK downloads exceeded 300 million, up from 100 million earlier this year. Hundreds of thousands of users daily employ MCP on Claude, powering features such as Claude Cowork, Managed Agents, and Claude Code Channels.

With MCP’s continued support for production agents, we share practical patterns for building these integrations—from high‑performance servers to context‑efficient clients, and how Skills cooperate with the protocol.

3. Building efficient MCP servers

Our directory lists over 200 MCP servers serving millions of daily users. Collaboration with enterprise developers revealed key design patterns that determine whether an agent can reliably use a server.

3.1 Remote servers for maximum coverage

Remote servers provide distribution capability—the only way to support Web, mobile, and cloud‑hosted agents uniformly. Building a remote server lets any agent, wherever it runs, use your system.

3.2 Organize tools by intent, not endpoint

Fewer, precisely described tools beat exhaustive API mirroring. Instead of wrapping each API endpoint, group tools by intent so an agent can accomplish a task with a few calls. For example, create_issue_from_thread is far stronger than the combination get_thread + parse_messages + create_issue + link_attachment. See “Writing Tools for Agents” for more patterns.

3.3 Code orchestration for large surface areas

When a service offers hundreds of operations (e.g., Cloudflare, AWS, Kubernetes), intent‑grouped tools may not cover everything. Expose a thin tool layer that accepts code: the agent writes a short script, the server executes it in a sandbox against your API, and returns the result. Cloudflare’s MCP server demonstrates this—two tools (search and execute) cover ~2,500 endpoints while consuming ~1 K tokens.

3.4 Rich semantics where needed

MCP Apps, the first official protocol extension, let tools return interactive UI elements (charts, forms, dashboards) rendered inline in the chat. Servers offering MCP Apps see higher adoption and retention than text‑only servers. Use this extension in Claude.ai, Claude Cowork, and other AI tools to surface UI at critical moments.

Elicitation allows a server to pause a tool call and request user input. Form mode sends a simple schema for the client to render a native form (e.g., missing parameters, destructive‑operation confirmation). URL mode redirects the user to a browser for downstream OAuth, payments, or credential collection, keeping the user in the flow. Form mode is widely supported; URL mode is currently in Claude Code with more clients joining.

3.5 Standardized authentication

Standardized auth makes MCP practical for cloud‑hosted agents. When OAuth is needed, the latest MCP spec supports CIMD (Client ID Metadata Documents) for client registration, giving users a faster first‑time auth flow and reducing unexpected re‑auth prompts. This scheme is supported in MCP SDKs, Claude.ai, and Claude Code, and is being widely adopted.

Claude Managed Agents solves token handling: users register an OAuth token once; sessions reference a vault ID, and the platform injects the correct credential on each MCP connection, refreshing as needed—no custom key store or per‑call token passing required.

4. Making MCP clients more context‑efficient

MCP standardizes how AI agents (clients) connect to and use tools and data sources (servers). Servers expose capabilities securely; clients orchestrate them while managing context. To build an MCP client, use progressive disclosure to save context.

4.1 Tool search for on‑demand loading

Tool search lazily loads tool definitions instead of pre‑loading everything. The agent can search the catalog at runtime and fetch only needed definitions. In our tests, tool search reduced token consumption for tool definitions by over 85 % without sacrificing selection accuracy.

4.2 Programmatic tool calling for in‑code result handling

Programmatic tool calling processes tool results inside the execution sandbox rather than returning raw results to the model. This enables the agent to loop, filter, and aggregate multiple calls in code, feeding only the final output into context. Our tests showed a ~37 % token reduction for complex multi‑step workflows.

These patterns combine naturally across servers: slimmer context, fewer round‑trips, faster responses. See “Advanced Tool Use” for details.

5. Coordinating MCP servers with Skills

Skills and MCP complement each other. MCP provides the tools and data; Skills teach the agent how to use them procedurally. The strongest agents use both, allowing MCP servers to scale to dozens of connections. Two common patterns exist:

5.1 Package Skills and MCP server as a plugin

Claude plugins abstract this combination, letting developers bundle Skills, MCP servers, hooks, LSP servers, and dedicated sub‑agents into a consumable distribution unit. This unifies multiple context providers with minimal friction.

Combining MCP servers with Skills makes Claude act like a domain expert. See our data plugin for Cowork (10 Skills, 8 MCP servers) that integrates Snowflake, Databricks, BigQuery, Hex, etc.

5.2 Distribute Skills from MCP server

Providers increasingly ship a Skill together with an MCP server, giving agents both the raw capability and a playbook for using it. Canva, Notion, Sentry already follow this model on Claude. To make this pairing portable across clients, the MCP community is developing an extension that delivers Skills directly from the server, ensuring the client inherits the expertise and stays in sync with the API version. We expect broad adoption once the extension stabilizes.

6. Layered network effects

In practice, mature integrations combine all three paths: API as the base layer, CLI for local‑first environments, and MCP for cloud agents.

As production agents migrate to the cloud, MCP becomes the critical layer that generates compound network effects. A single remote server can be accessed by any compatible client across any deployment environment, with authentication, interactivity, and rich semantics handled by the protocol. As more clients adopt the spec and more extensions are added, the same server gains new capabilities without any new code.

When your goal is to let cloud‑grade production agents access your system, build an MCP server and apply the patterns above. Each integration built on MCP strengthens the ecosystem: fewer edge cases to solve individually, less custom integration maintenance.