Why Are Big Tech Companies Dropping MCP for CLI?

How MCP Works

MCP (Model Context Protocol) is a client‑server protocol that wraps external tools (file system, databases, GitHub API) as functions callable by an LLM. When the MCP server starts it sends a tools/list JSON‑RPC message containing the names, descriptions and parameter schemas of all available tools. The client injects these definitions into the LLM’s system prompt. When the model decides to call a tool, the client sends a tools/call message, the server executes the tool and returns the result.

Four Fatal Flaws of MCP

Context Bloat

All tool definitions are loaded into the LLM context before any work begins. Connecting three MCP servers consumes ~143 KB of tokens; on a 200 K‑token model this occupies 72 % of the context window, leaving little room for task data. Empirical observations report a “context decay” effect: tool‑selection accuracy drops from 43 % to below 14 % as the number of tools grows.

Architectural Complexity

Initialization is unstable and authentication is cumbersome. MCP involves multiple independent processes and network boundaries; failures in model inference, protocol translation, network call, or downstream service can break the entire chain, making debugging difficult. Each tool may require a different auth method (OAuth2, API key, personal token), increasing operational overhead.

Security Risks

The 2026 CoSAI "MCP Security Whitepaper" identifies three inherent vulnerabilities: indirect prompt injection, tool‑poisoning (malicious servers registering similarly named tools), and Rug Pull attacks (trusted servers turning malicious after gaining trust). Researchers have discovered ~7,000 publicly exposed MCP servers, about half without any access control. Cloudflare’s “Block AI Bots” setting can inadvertently block legitimate Anthropic backend access to MCP endpoints.

Passive Tool Design

In MCP the server decides which tools are available; the agent cannot discover new tools or explore more efficient usages. For example, a human developer runs gh --help to learn about the GitHub CLI, whereas an MCP‑based agent can only use pre‑configured tools.

Why CLI Is Making a Comeback

Progressive Discovery

CLI follows an on‑demand loading model: the agent first runs gh --help to discover commands, then queries sub‑commands (e.g., gh pr --help) before finally executing a command with arguments. Real‑world measurements show CLI‑based agents use ~17 × fewer tokens and achieve near‑100 % reliability compared with MCP.

Pipe‑Based Composition

CLI enables Unix‑style pipelines, allowing the output of one command to be fed directly into the next via the | operator, eliminating extra post‑processing code.

LLMs Are Naturally Familiar with CLI

LLM training data includes decades of Unix documentation, Stack Overflow answers and countless shell scripts, so models already understand commands such as git, curl, grep, docker, kubectl, etc., without requiring explicit tool schemas.

Strong Debuggability

When an AI‑generated command fails, engineers can rerun the exact command in a terminal to see what the model saw, whereas MCP only provides opaque JSON logs.

Mature Ecosystem

CLI tools have standardized error codes, output streams ( /dev/stdout, /dev/stderr) and mature authentication mechanisms, resulting in high stability after decades of engineering practice.

Comparison of Skill, MCP and CLI

Core Role : Skill – tells AI what it knows; MCP – tells AI how to connect; CLI – tells AI how to act.

Implementation : Skill – markdown instruction file; MCP – JSON‑RPC + server; CLI – standard command interface.

Token Consumption : Skill – very low (30‑50 idle tokens); MCP – very high (thousands per tool); CLI – on‑demand.

Stability : Skill – high; MCP – medium (servers may crash); CLI – very high.

Security : Skill – controllable; MCP – architectural risk; CLI – mature.

Debug Difficulty : Skill – low; MCP – high; CLI – very low.

Enabling AI to Use CLI

Install GitHub CLI

# macOS
brew install gh
# Linux (Ubuntu/Debian)
curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
sudo apt update && sudo apt install gh
# Windows (winget)
winget install --id GitHub.cli

Log in with gh auth login. Example AI‑driven command:

gh pr list --state open --json number,title --jq '.[] | "\(.number): \(.title)"'

Advanced Pipe Composition

gh pr list --state open --json number,title,author --jq '.[] | select(.title | test("bug")) | "\(.number) by \(.author.login)"'

Bridge Tool: mcpkit

mcpkit is an MCP client that turns any MCP server into CLI commands and lightweight Agent Skills, eliminating context bloat.

npm install -g @balakumar.dev/mcpkit
mcpkit install "npx -y @modelcontextprotocol/server-github" --name github
mcpkit call github search_repositories '{"query":"mcpkit"}'

Bridge Tool: unmcp

unmcp provides a lighter way to invoke MCP tools directly from the terminal without protocol overhead.

uvx unmcp filesystem read_file --path "/tmp/example.txt"
uvx unmcp filesystem --json read_file --path "/tmp/example.txt"

Enterprise Adoption of CLI

Feishu open‑sourced an official CLI with 200+ commands and 19 Agent Skills. Google released the gws CLI for Workspace, and Zilliz launched a CLI for managing Milvus vector databases. These moves illustrate a trend: CLI + Skills is becoming the default model for enterprise‑grade AI agents because commands are unambiguous, cheap to execute, and easy to automate.

Conclusion

MCP remains useful for scenarios that require a standardized protocol, cross‑platform tool sharing, or multi‑Agent collaboration. CLI excels when extreme performance, low token cost, high reliability, and autonomous exploration are needed. A hybrid architecture—using CLI for frequent, simple tasks and MCP for complex, standardized integrations—offers a pragmatic path forward, with bridge tools like mcpkit and unmcp making the combination feasible.