The MCP Delusion: Why “Context Rot” is Killing AI Agents (And Why CLI is the Real Alpha)

If you built an MCP server in 2024, you probably thought you were future-proofing your software.

You weren’t. When Anthropic announced the Model Context Protocol, the industry collectively lost its mind. Every company scrambled to ship MCP servers as proof they were “AI first.” Massive resources poured into new endpoints, new wire formats, and new authorization schemes.

It became the default answer to how agents should connect to software.

But as the dust settles, a quiet reversal is happening among elite engineers. The smartest teams are ripping out their complex MCP servers and returning to an abstraction invented 50 years ago: the Command Line Interface (CLI).

If you are trying to build autonomous coding agents, relying on standard MCP tool-calling is building a great product on a rotting foundation.

Here is why MCP is failing in production, the anatomy of the invisible enemy killing your agents, and the exact playbook for building the interfaces LLMs actually want to use.

I - Invisible Enemy: Context Rot

When you connect an MCP server, you aren’t just giving the model a tool; you are injecting massive amounts of metadata — tool names, descriptions, parameter schemas, and usage details — directly into the model’s working memory.

A server with two tools is fine. A server with a dozen tools is harder. Multiple servers with fifty tools is a graveyard.

This creates Context Rot. The context window gets polluted with thousands of tokens of preemptive instructions for tools the agent might not even use.

The model’s attention is fractured. Before it can even begin reasoning about your task, it has to navigate a maze of JSON schemas.

(Yes, Anthropic recently introduced “Tool Search” to dynamically load MCPs when they exceed 10% of the context window. But that is a band-aid on a bullet wound. It manages the bloat; it doesn’t fix the underlying architectural flaw).

II - Latency Death Spiral

The “one-tool-call-per-LLM-turn” pattern does not scale.

Think about how MCP forces a model to execute a 5-step task: LLM → calls Tool A → result back to LLM → LLM reads it → calls Tool B → result back to LLM…

Every single intermediate result must pass back through the neural network just to be forwarded to the next call. For a 10-tool task, you are looking at 11 LLM round-trips. At roughly 2 seconds per call, that’s 22 seconds of pure latency, burning thousands of tokens on intermediate steps.

The best tools are the ones that work for both humans and machines. MCP tried to build a better abstraction. Turns out we already had a pretty good one.

III - The Unix Prophecy

Fifty years ago, Unix made a radical design decision: everything is a text stream. Programs don’t share complex binary memory; they communicate through text pipes. Small tools do one thing well, composed via `|` into workflows.

Fifty years later, LLMs made an identical decision: everything is tokens. Their “thinking” is text, their “actions” are text, and the feedback they receive must be text.

These two decisions, made half a century apart, converge perfectly. An LLM is essentially a terminal operator — one that is faster than any human and has already memorized billions of lines of shell scripts, CI/CD pipelines, and Stack Overflow answers.

When you give an agent a CLI, you don’t need to teach it how to use it. It already knows. Instead of forcing a reasoning model to carefully format a rigid JSON payload for an MCP endpoint, you just give it terminal access.

It can use `cat /var/log/app.log | grep ERROR | wc -l` in a single bound. One call replaces three rigid function calls. It composes natively. It uses SSO and local auth (like `gh auth login` or `aws sso login`) instead of requiring custom MCP authentication layers.

And when it breaks? You don’t have to spelunk through JSON transport logs. You just look at the `stderr`.

IV - Middle Ground

Is MCP completely dead? No.

MCP is a blunt instrument, but it has its place.

• Client-Side Sandboxes: If the user is on a web UI (like Claude.ai) and needs to securely connect to a local file system without running arbitrary code.
• Deep Introspection: Tools like Playwright use MCP for specialized agentic loops requiring persistent state and rich DOM introspection, while reserving CLI for high-throughput, token-efficient command execution.
• Highly Typed Data: Database queries or strict GraphQL API transactions where string concatenation carries injection risks.

But for the vast majority of agentic workflows — especially coding, data exploration (via tools like jq or duckdb), and infrastructure management — the center of gravity has permanently shifted to code execution, skills, and CLI.

V - 3-Step CLI Protocol for Agents

If your company wants AI agents to actually use your product, stop vibecoding lazy wrappers over your API endpoints. You need to design your CLI for a non-human operator.

Here is the exact framework to make your CLI agent-native:

1. Progressive Discovery (Don’t stuff the prompt) Do not load your entire documentation into the system prompt. Rely on progressive — help.

• Level 0: The agent gets a basic command list (cat, ls, grep).
• Level 1: If the agent runs a command with no arguments, it returns usage syntax.
• Level 2: If it runs a subcommand, it returns specific parameters. Give the agent just enough information to take the next step.

2. Error Messages as NavigationAgents cannot Google their errors. Traditional CLI errors just report failure. Agentic CLI errors must report the failure and the solution.

• Bad: cat: binary file
• Good: [error] cat: binary image file (182KB). Use: see photo.pngNever, ever drop stderr. If a command fails silently, the agent goes blind and will blindly retry 10 different package managers, wasting time and money.

3. Two-Layer Architecture (Overflow Protection) LLMs have finite context windows. If your CLI dumps a 10MB log file into the terminal, the agent forgets its original instructions. You must separate execution from presentation. If an output exceeds 200 lines, truncate it cleanly. Tell the agent: “Output truncated. Full output saved to /tmp/cmd-3.txt. Use grep to explore.” Transform large data exploration into a native skill the LLM already possesses.

Agent skills is also something that heavily favours CLI workflows, with the new CLIs that are being launces that the AI might have no idea about, agent skills bridge the gap with progressive disclosure.

We are entering an era where you don’t connect tools to an agent; you drop the agent into an environment and let it build its own leverage.

Ship a good API. Then ship a relentless, fast, text-native CLI. The agents will figure out the rest.