Is MCP Really Dead? A History of AI Hype — Told Through the Rise and Fall of a Protocol

In November 2024, Anthropic quietly dropped a bomb on the developer community.

It was called the Model Context Protocol — or MCP, for those who enjoy acronyms that sound more mysterious than they are. At first glance, it looked like yet another AI developer tool. Then, a few months later, Sam Altman posted something on X that changed everything: “People love MCP and we are excited to add support across our products.” [¹] OpenAI had raised its hand. Google DeepMind followed. Microsoft followed. Developers lost their minds — in the best possible way.

That was roughly fifteen months ago.

Today, in the same communities, you’ll hear a different tone: “Wait, are people still building MCP servers?”

Something shifted. Let’s figure out what.

1. The Essay That Started the Argument

On February 28, 2026, a developer named Eric Holmes published a blog post with a title that didn’t exactly bury the lede: “MCP is dead. Long live the CLI.” [²]

His argument, in plain terms: LLMs are already good enough to use tools like git, docker, and kubectl — the classic command-line tools that every developer already has installed. So why build an entirely new protocol to do the same thing?

He wasn’t being a contrarian for sport. He laid out real frustrations:

MCP servers are flaky to initialize (and restart — a lot)

Re-authentication is constant and tedious

Permission controls are blunt: all-or-nothing, no nuance

CLIs, by contrast, are stable, inspectable, debuggable — by humans and agents alike

His bottom line: “Ship a good API and a good CLI. The agents will figure it out.”

The post hit the top of Hacker News. [³] At the time of writing, the thread had accumulated over 400 points and nearly 300 comments — numbers that keep climbing. Which is to say: he touched a nerve.

But here’s the thing — Holmes himself isn’t calling for MCP’s execution. He acknowledges it has a role where no CLI alternative exists.

The “MCP is dead” framing is, in part, a provocation. And provocation, as it turns out, is how the internet processes uncomfortable truths.

2. Wait — What Even Is MCP? (A Terminology Rescue Mission)

Before going further, we need to talk about a problem. Even experienced AI developers mix up these four terms constantly. If you’ve ever nodded along while secretly unsure what anyone was talking about, this section is for you.

Concept Analogy What It Does Examples

Agent The brain Sets goals, plans, decides, executes Claude Code, Cursor, Devin

MCP A telephone interpreter Standard protocol connecting AI to external services GitHub MCP, Slack MCP

CLI The hands Runs commands directly git, docker, aws

Skills A how-to manual Packaged instructions for how an agent should behave Claude’s Skills

The flow looks like this:

The critical point: MCP is not an agent. CLI is not an agent. They are two different ways the agent reaches out and touches the world — like choosing between a telephone and walking over in person.

CLI is direct, transparent, and debuggable. MCP is standardized and better suited for services that have no CLI equivalent — Slack, Notion, Figma. Neither is universally superior. They solve different problems.

The confusion arose because, for a while, everyone talked about MCP as if it were the agent. As if learning MCP was learning AI development. That category error is the real story here.

3. The Category Error That Started Everything

The confusion arose because of a mistake that was never technical — it was categorical.

Somewhere between the GitHub launch and Sam Altman’s endorsement, developers started treating MCP as if it were the architecture of AI systems, rather than one interface layer within them.

Learning MCP became synonymous with “learning AI development.” Building an MCP server became a signal of seriousness. The part got mistaken for the whole.

The real mistake wasn’t in the code. It was in the category. MCP was never the brain — it was always just one kind of hand.

This matters because once you misclassify a technology, your expectations misfire in every direction.

You over-invest where the tool isn’t needed. You under-appreciate where it genuinely helps. And when reality corrects you, the correction feels like failure rather than what it actually is: calibration.

4. Four Psychological Reasons the Excitement Faded

Technology doesn’t generate hype on its own. Humans do that part. Here are the four psychological mechanisms that inflated — and then deflated — MCP’s moment.

1) The Bandwagon Effect

When OpenAI and Google publicly endorsed MCP, the implicit message was: if you’re not building MCP servers, you’re not serious about AI. Developers piled in. A recurring theme in the community is that builders outnumber actual users by an order of magnitude — though the exact ratio is hard to measure. [⁴] A lot of hammers in search of a nail.

2) FOMO — Fear of Missing Out

“If I don’t learn MCP right now, I’ll be left behind.” This particular anxiety is productivity’s natural enemy. It pushes people to implement before they’ve asked whether implementation is warranted.

3) The Power of a Good Metaphor — Gone Wrong

MCP was pitched as “the USB-C of AI.” Elegant. Memorable. And just misleading enough to be dangerous. USB-C works in every port, on every device, everywhere. MCP at that stage was a promising protocol with real limitations. But people remembered the metaphor, not the footnotes.

4) Security Concerns Arrive on Schedule

In April 2025, security researchers published findings on vulnerabilities in MCP-based systems: prompt injection, tool poisoning, expanded attack surfaces. [⁵] But the deeper concern wasn’t the protocol itself — it was the autonomy it granted agents to invoke external tools whose side effects humans might not fully inspect or reverse.

When an LLM can call delete_record() or send_email() without a confirmation step, the blast radius of a mistake grows considerably. In practice, the risk concentrates at the decision boundary — when an agent chooses to call a tool — not at the serialization format of the call itself.

MCP didn’t create this problem, but it made it more visible. When a technology’s real risks become visible, the enthusiasm that ignored them tends to recalibrate fast.

5. The Social Factor: A Bigger Flame Appeared

There’s also a simpler reason MCP’s heat faded. Something dramatically hotter showed up.

In November 2025, an Austrian developer named Peter Steinberger — formerly the founder of PSPDFKit, which he sold for a reported $800 million — pushed a weekend project to GitHub. He called it Clawdbot.

It was a personal AI assistant that could connect to WhatsApp, Telegram, Discord, and a dozen other messaging platforms simultaneously, running locally on your own device.

Then Anthropic’s legal team sent a letter. The name was too close to “Claude.” [⁶]

In a Discord channel at 5 AM, the community brainstormed a new name. They landed on Moltbot — evoking a lobster shedding its shell, growing into something bigger. The mascot got a name: Molty 🦞, a space lobster. Three days later, Steinberger liked a different name even more, and the project became OpenClaw.

What happened next was difficult to believe even as it was happening. [⁷]

The project crossed 100,000 GitHub stars. Then 2 million visitors in a single week. By mid-February 2026, it had accumulated over 200,000 stars — rivaling the fastest adoption curves ever recorded for major open-source projects, in a fraction of the time it took React or Kubernetes to reach comparable numbers. [⁸]

All of this while Steinberger was reportedly spending $10,000–$20,000 per month of his own money to keep the infrastructure running — a figure he disclosed himself. [⁹]

On February 15, 2026, Sam Altman announced that Steinberger was joining OpenAI to “drive the next generation of personal agents.” [¹⁰] OpenClaw would move to an independent foundation and remain open source.

Meanwhile — and this is the detail you have to appreciate — Anthropic’s first response to the project had been to send lawyers about the name. The project that was originally built on Claude’s API, actively driving API revenue and developer attention to Anthropic, ended up at OpenAI. As one newsletter put it: “Anthropic sent lawyers. OpenAI sent a job offer.” [¹¹]

6. The Clone Ecology: Every Hype Has Its Offspring

Right on schedule, GitHub filled with variations:

Moltbook — a social network where AI agents talk to each other (yes, this exists)

nanobot — “OpenClaw, but 99% lighter”

ClawWork — “your AI coworker”

secure-openclaw — the security-conscious fork

antfarm — multi-agent coordination built on OpenClaw

If this pattern looks familiar, it should:

Every major hype cycle in AI tooling spawns an ecosystem of derivatives. Most disappear. A few survive and become genuinely useful. The trick, as always, is telling them apart before the sorting happens.

7. Why Developers Chase Hype (An Honest Look)

To understand this cycle, you need to understand that the AI developer community is not one thing. It’s three overlapping groups operating simultaneously:

Builders want to solve problems. For them, new technology is a means. They adopt what works and discard what doesn’t, mostly quietly.

Speculators are optimizing for position. Early adopters accumulate GitHub stars, followers, speaking invitations, and career capital. They’re not wrong to do this — it just means their adoption decisions track momentum, not merit.

Believers have internalized a narrative. “This is the future.” They provide the emotional energy that turns a tool into a movement.

When all three groups pile into the same technology at the same moment, hype becomes self-reinforcing. When Speculators exit for the next opportunity, and Believers migrate their conviction to the next narrative, what remains is the Builders — who were the only ones asking practical questions all along.

This isn’t unique to AI. Tulips. Dot-com. NFTs. Metaverse. The specific assets change. The psychological mechanics don’t.

8. So What Actually Happens to MCP?

The declaration that MCP is dead is half right and half premature.

A more useful frame is Gartner’s Hype Cycle: every significant technology travels from Innovation Trigger through Peak of Inflated Expectations, down into the Trough of Disillusionment, then slowly up the Slope of Enlightenment to the Plateau of Productivity. [¹²]

MCP is somewhere between the trough and the slope. Which, historically, is where the interesting work actually begins.

The evidence for this reading is structural: in December 2025, MCP was contributed to the Linux Foundation’s Agentic AI Initiative (AAIF), with OpenAI, Google, Microsoft, AWS, and Cloudflare all signing on as founding members. [¹³]

This is the moment a technology stops being one company’s bet and becomes shared infrastructure. Competing organizations do not jointly fund standards they believe are dying. They fund standards they intend to build on.

Eric Holmes is right that CLI tools are often simpler, more debuggable, and sufficient for many use cases — especially in developer-facing workflows. But as one counterargument put it concisely: “Not giving an AI agent unrestricted root access to enterprise systems is not obstruction. That’s a CISO doing their job.” [¹⁴] For enterprises, regulated industries, and multi-AI environments, MCP’s structured access model isn’t overhead — it’s the point.

The cleaner conclusion: MCP didn’t die. It got sorted. The use cases that never needed it are moving on. The use cases that genuinely need it are quietly implementing it.

9. So When Do You Actually Use MCP vs CLI?

Since this is where the debate generates more heat than light, here’s a practical frame.

Choose CLI when:

You’re in a developer-facing workflow where the tool already exists (git, docker, kubectl)

Debuggability and reproducibility matter — you want to run the same command yourself and see exactly what happened

You need composability: piping outputs between tools (jq, grep, duckdb)

Local environment access is given and latency matters

Choose MCP when:

The service has no CLI equivalent (Slack, Notion, Figma, Google Workspace)

You’re in a remote or cloud environment where local binary installs aren’t feasible

You need centralized authentication, audit logging, or approval gates — especially in enterprise or regulated contexts

Multiple agents need to share a consistent interface to the same service

Where both become dangerous: Any tool that performs irreversible write actions — sending emails, deleting records, processing payments, pushing to production — needs a human confirmation layer regardless of whether it’s reached via CLI or MCP. The protocol is not the governance. The governance is the governance.

This is what the MCP vs CLI debate often misses: the real architectural question isn’t which interface layer, it’s what happens at the decision boundary before the call is made.

10. The Insight Underneath All of This

The MCP story isn’t really about a protocol. It’s about what happens when a technically real innovation meets a community with a cultural habit of treating every new tool as a historic turning point.

The pattern, compressed:

And then the cycle continues. OpenClaw was a genuinely remarkable project. But the ecosystem of clones that followed — and the security incidents that arrived shortly after — are already running the same script MCP ran in 2025.

The question worth asking, for anyone following AI development:

Am I adopting this because it solves my problem, or because everyone else seems excited about it?

The developers who answer that question honestly are the ones still standing after each cycle ends — quietly building things that actually work, long after the discourse has moved on.

That’s what remains when the hype moves on. Not the buzzword. The builders.

And the protocol? It doesn’t die. It moves from the spotlight into the infrastructure layer — where the real work begins.

The lobster is still out there. 🦞 The claw is the law.

Thanks for reading Flamehaven Insights! Subscribe for free to receive new posts and support my work.

References

[1] Sam Altman on X endorsing MCP — March 2025

[2] Eric Holmes, “MCP is dead. Long live the CLI” — ejholmes.github.io, Feb 28, 2026

[3] Hacker News discussion thread — news.ycombinator.com (points/comments time-sensitive; thread continues to accumulate)

[4] Glama, “We’re Entering the Real Adoption Phase of the MCP Hype Cycle” — glama.ai, Jan 20, 2026

[5] Tobias Pfuetze, “The MCP vs. CLI Debate Is the Wrong Fight” — Medium, Feb 2026

[6] TechCrunch, “OpenClaw creator Peter Steinberger joins OpenAI” — techcrunch.com, Feb 15, 2026

[7] Peter Steinberger, “OpenClaw, OpenAI and the future” — steipete.me, Feb 2026

[8] “OpenClaw: 190K GitHub Stars in 14 Days” — AI in Plain English / Medium, Feb 2026 (secondary; cross-reference with [7])

[9] Cost figures disclosed by Steinberger directly — see steipete.me; as further reported in Level Up Coding / Medium, Feb 2026

[10] CNBC, “OpenClaw creator Peter Steinberger joining OpenAI, Altman says” — cnbc.com, Feb 15, 2026

[11] AI Collective, “The Brief: OpenClaw’s creator heads to OpenAI” — Substack, Feb 23, 2026

[12] Gartner Hype Cycle — Wikipedia overview

[13] Linux Foundation AAIF (Agentic AI Initiative) — MCP contribution announcement, Dec 2025; OpenClaw GitHub repository — github.com/openclaw/openclaw

[14] Tobias Pfuetze, “The MCP vs. CLI Debate Is the Wrong Fight” — Medium, Feb 2026