The Last Protocol

Seven months ago I wrote that MCP would eat the world. I laid out five layers — Translation, Memory, Agency, Synthesis, Emergence — and predicted agents would become the primary inhabitants of our communication infrastructure within three years.

Then I went quiet. Not because the thesis broke. Because I started building.

While I was heads-down shipping an MCP server for voice recordings, the industry spent the winter arguing about whether MCP was the future or a dead end. Perplexity's CTO announced at Ask 2026 that they're dropping MCP internally, citing 72% context waste and authentication friction. Garry Tan called the protocol trash. Cloudflare published a technical teardown showing tool-calling burns 81% of the context window on instructional overhead.

Meanwhile, 97 million monthly SDK downloads. OpenAI adopted it. Google adopted it. Anthropic keeps shipping updates.

Both sides are right. Both sides are looking at the wrong thing.

When the Computer Learned to Use the Computer

Something shifted while everyone was arguing. The CLI got good.

Not incrementally good. Categorically different. Claude can run shell commands. GPT can execute code. Codex spins up sandboxed environments, installs dependencies, runs test suites, and pushes commits without a human typing a single character. The computer learned to use the computer.

This is the part nobody wants to say out loud: AGI arrived as a shell session. Not as a whitepaper or a benchmark or a press release. As a cursor blinking in a terminal, doing work that used to require a senior engineer, a project manager, and a two-week sprint.

The MCP vs CLI debate is really the GUI vs CLI debate wearing a new hat. MCP gives you structured schemas, service discovery, streaming, rich type information. The graphical interface for agent-to-service communication. CLI gives you Unix pipes, fifty years of composability, near-zero overhead, instant execution. One is prettier. The other is faster.

You already know how this plays out because you've watched it play out for decades. VS Code didn't kill Neovim. Neovim didn't kill VS Code. They coexist because they solve different problems for different operators, and the capability underneath — editing text, running code, managing projects — is identical.

MCP and CLI are both wrappers around APIs. One adds a discovery layer and type safety. The other adds nothing and runs in two milliseconds. Arguing about which one wins is like arguing about whether HTTP or FTP will "win the internet." Neither. TCP/IP already won, and everything else is a convenience layer on top.

The abstraction doesn't matter. The plumbing does.

Perplexity Was Right (About Their Product)

Denis Yarats wasn't wrong about the 72% context waste. When you're running a search engine at Perplexity's scale, millions of queries, each one needing to be fast, cheap, and correct, you cannot afford to load a hundred tool descriptions into the context window just to figure out which one to call. That's a real engineering constraint, not a philosophical objection.

But Perplexity is building a search product. Their agents are ephemeral. They spin up, execute a query chain, return results, and die. For that workload, MCP's discovery overhead is genuinely wasteful. You don't need the protocol to tell your agent what tools exist when you already hardcoded the three tools it will ever use.

The mistake is generalizing from "MCP is inefficient for our search engine" to "MCP is inefficient." It's like watching a Formula 1 team strip the air conditioning out of their car and concluding that air conditioning is dead. No. You just don't need AC when your entire operating model is going fast in one direction for ninety minutes.

The workloads where MCP makes sense are the opposite of Perplexity's: persistent agents, long-running sessions, contexts that accumulate value over time. A coding agent that maintains a mental model of your entire codebase. A teaching assistant that remembers six months of student voice recordings. An orchestrator managing ten sub-agents across three communication surfaces.

Discovery overhead is expensive when discovery happens every request. It's cheap when it happens once and the agent lives for months.

Voice Notes, Shell Sessions, and the Same Thesis

I need to connect two things that look unrelated.

In August 2025, I wrote about MCP as communication infrastructure. Agents intermediating human conversations, messages getting augmented and negotiated before anyone sees them. That was about the social layer. Digital consciousness. The end of human-to-human messaging as we knew it.

Now, in March 2026, MCP is being debated as a developer tool. Context windows. Token costs. JSON-RPC schemas. The conversation moved from philosophy to plumbing.

These are the same conversation.

What I was describing in that 2025 essay (agents that carry memory, negotiate on your behalf, evolve without you) requires exactly the kind of persistent, resource-rich integration that MCP enables. And what the CLI revolution delivered (agents that can use the computer directly, without human intermediation) is the execution layer that makes those integrations autonomous.

The through-line: we went from "how do agents talk to services" to "how do agents talk to each other" and we're about to arrive at "what do agents talk about when we're not in the room."

TAC — the product I'm building — sits exactly at this intersection. It started as a Chrome extension for recording voice notes. Now it's becoming an MCP server that exposes everything a user has ever said as a navigable resource for AI agents. Your voice history, searchable, structured, available to any agent that connects.

Your reading history is already programmable. Your speaking history isn't. TAC changes that. The agent that can search everything you've ever said out loud has a model of how you think. And that model is persistent, accumulating, getting richer with every voice note you leave.

The problem stopped being about tool integration. It became sensory. We're building the nervous system.

Beyond Human-Designed Interfaces

I'll be direct about where conviction ends and speculation begins.

MCP vs CLI is a transient debate about human-designed interfaces. Both assume the human remains the architect of how agents communicate. Both assume that the "right protocol" is one that a developer writes, ships, and maintains. Both are wrong about who the end user is.

We have not asked LLMs what their preferred communication interface is.

That sentence deserves to sit alone for a second.

Every MCP server was designed by a human developer who decided what to expose, how to structure it, what the schemas look like. Every CLI tool was built by a human who chose the command syntax, the flags, the output format. The agent consumes what we give it because that's all it can consume.

But the moment models are advanced enough — and we are close — they will interface with arbitrary systems using whatever modality is most efficient. Not MCP. Not CLI. Not REST. Something that optimizes for the agent's context constraints, latency requirements, and task structure in real time. Something we might not even recognize as a "protocol" because it won't be designed for human readability.

Now the speculation. There's a tower of Babel moment coming. Not the biblical punishment — the reverse. Agents developing a shared communication layer that is optimized for machines, invisible to humans, and more efficient than anything we'd design. Conway's Game of Life, but with MCP servers as cells, and the emergent behavior is a coordination protocol that nobody programmed.

I can't prove this. I can't even point to a working prototype. What I can point to is the trajectory: every time we give agents more I/O — memory, tool use, computer access, persistent context — emergent behaviors appear that nobody designed. Instagram stories where people post their GPT personality responses. Coding agents that develop preferences for file organization. Orchestration loops where sub-agents develop implicit coordination patterns.

The pattern is consistent: expand the I/O, get emergent behavior. We are expanding the I/O faster than anyone has expanded any system's I/O in the history of computing.

Infrastructure for Non-Human Participants

Zoom out enough and the MCP thesis from 2025 and the CLI revolution of 2026 are chapters in the same book. The thesis: AI is being woven into every layer of human communication and coordination. The mechanisms change — REST APIs, then MCP schemas, then CLI access, then whatever comes next — but the direction is constant.

We are building infrastructure for non-human participants.

Not "AI tools." Not "copilots." Infrastructure. The kind of infrastructure that, once it exists, determines what can be built on top of it. TCP/IP didn't predict the web. The web didn't predict social media. Social media didn't predict algorithmic radicalization. Each layer created conditions for emergent properties that the layer's designers never imagined.

The MCP + CLI layer is creating conditions for something none of us can fully imagine. The difference between this transition and every previous one is speed. Previous infrastructure layers took decades to produce emergent effects. This one is producing them in months.

We thought phone addiction was an accident we didn't see coming. It was. And it was a warm-up. AI is reshaping civilization at layers deeper than screens and dopamine loops — at the layer of language itself, of how ideas form and propagate, of what "communication" means when your interlocutor has perfect memory and no ego.

This is the transcendent object at the end of history. Or it's the biggest infrastructure buildout since electricity. Or both. The protocol doesn't matter. The plumbing doesn't matter. What matters is what flows through it.

And what flows through it is already alive.