Why MCP Is Becoming Obsolete: A Critical Review of the Model Context Protocol

TL;DR – MCP is losing relevance

The Model Context Protocol (MCP), launched in November 2024, is increasingly unnecessary because today’s large language models can discover and invoke APIs or command‑line tools directly, eliminating the context bloat and operational overhead that MCP servers introduce.

The Original Promise of MCP

MCP was created by Anthropic to let agents access external services through a unified JSON‑RPC interface. Early models needed a thin abstraction layer to translate natural‑language intent into concrete tool calls, and MCP quickly gained traction as a plug‑and‑play solution for agents without terminal access.

"MCP was released in November 2024 by the Anthropic team as a protocol designed to help agents connect to external services and data sources"【1】.

Why the Protocol Started to Crumble

Context bloat from ever‑growing tool sets

Each MCP server bundles many tools, each with its own schema. When agents load several servers, the combined schema overwhelms the model’s context window, forcing developers to prune or proxy tools.

"Each server would come with multiple tools, each with its own schema, which started to overload the context of all of these models"【1】.

Better models can generate and execute code directly

Modern agents (Claude Code, Meta Muse, OpenClaw, etc.) can write scripts, compose multi‑service workflows, and call APIs they have never seen before. Cloudflare’s Code Mode demonstrates this shift by letting LLMs generate sandboxed scripts instead of relying on MCP servers【1】.

"LLMs have gotten so good at this, Cloudflare even launched Code Mode, a better way to use MCP by having LLMs compose the various calls into scripts that can be executed in a sandbox"【1】.

Direct CLI discovery via --help

Agents now use the --help output of command‑line tools to infer arguments, removing the need for a separate discovery layer.

"The LLMs have figured out how to use the --help command to discover CLIs, so they no longer need MCP servers to access many services"【1】.

Counterpoints from the Community

Governance, authentication, and auditability

Several commenters argue that MCP still offers a controlled gateway for credential handling, permission boundaries, and audit logs—features that raw API or CLI access lacks.

"MCP makes it easier to provide control over exactly which external services an agent can access, handle authentication without exposing API keys, and offer strong audit logging" – @simonw.

Enterprise‑level tooling and plug‑in stores

Business users rely on one‑click MCP plugins in ChatGPT/Claude marketplaces, which bundle authentication and UI integration.

"MCPs are winning because within the ChatGPT and Claude apps, there are Plugin stores. These plugins are one‑click installation MCP servers, with support for authentication" – @whazor.

Remote‑control scenarios

When agents must interact with UI‑only applications or devices lacking a public API, an MCP server can expose a socket‑level command protocol.

"An MCP server still makes a lot of sense for remote‑controlling a UI application (like a game engine editor) which otherwise doesn't have any 'access points'" – @flohofwoe.

When Direct HTTP or CLI Beats MCP

  • Stateless, well‑documented REST endpoints – agents can attach an Accept: text/markdown header (or similar) to receive concise, agent‑friendly responses without extra schema.
  • Large JSON payloads – using jq or curl with size limits lets agents iteratively filter data, avoiding the token explosion caused by verbose MCP responses.
  • Security‑first environments – centralized auth and permission systems can be built directly into API gateways, eliminating the need for an extra MCP layer.

"We should start to standardize how agents use HTTP APIs directly. For example, agent clients could attach headers to identify themselves as agents, and servers could automatically send them response data as Markdown or text" – author.

Real‑World Examples of Emerging Practices

  1. Accept‑Markdown Header – Documentation sites now honor Accept: text/markdown to deliver rendered Markdown instead of HTML, reducing token count.
  2. Accept‑Language for SDK selection – Vercel and Shopify use language preferences to serve language‑specific SDK examples, improving relevance for agents.

The Path Forward – Not a Binary Choice

The community consensus is nuanced:

  • Retain MCP where it provides unique value – controlled credential handling, legacy UI automation, and enterprise plug‑in ecosystems.
  • Phase out MCP for simple, stateless services – replace with direct HTTP calls or CLI tools that agents can discover via --help.
  • Standardize agent‑friendly HTTP – introduce headers (e.g., User-Agent: agent/1.0) and content‑negotiation formats to make APIs as easy for LLMs to consume as MCP tools.

Conclusion

MCP was a pragmatic bridge for early LLMs, but the rapid improvement of model capabilities, the rise of code‑generation tools, and the overhead of maintaining MCP servers have shifted the cost‑benefit balance. Organizations should evaluate whether MCP still solves a genuine problem—such as secure credential mediation or remote UI control—before committing to it, and otherwise adopt direct HTTP or CLI approaches that are simpler, more performant, and less prone to context bloat.

Sources

Related