I have been thinking about MCP and whether it is already aging out of the role people are trying to give it.

My view is simple: MCP made sense when models were fragile, context was small, tool use was brittle, and agents needed to be kept inside a very carefully labeled box. You wrapped every capability in schemas, registries, typed calls, and broker layers because the model could not be trusted to explore the environment safely.

That was reasonable. It may also be temporary.

Once you have a strong agent sitting on top of a strong CLI, the architecture starts to invert. The agent can read help output, inspect files, run dry-runs, recover from errors, compose commands, write scripts, check logs, and learn the shape of an environment dynamically.

At that point, the command line stops being a human relic and starts looking like an agent operating system.

The CLI already has what agents need

A good CLI is discoverable, composable, scriptable, inspectable, and reversible. It exposes status. It has logs. It can stream output. It can be tested in small steps. It can be wrapped, piped, retried, and automated.

That matters because agents do not need pretty screens. They need operational surfaces they can reason about.

For a human, a dashboard may be the product. For an agent, a dashboard is often just friction. The agent wants the underlying commands, APIs, event streams, files, and structured logs. It wants the machinery, not the theater.

This is why CLI-native agents feel disproportionately powerful compared with polished enterprise chatbots. The chatbot is usually trapped in a product surface. The CLI agent is in the machine room.

Skill logic belongs in the tool surface

The next step is not one magic command called do_everything. That would be lazy design and brittle automation.

The better pattern is a CLI that teaches the agent how to operate it:

deploy --plan
deploy --dry-run
deploy status
deploy logs
deploy rollback

Now the agent can inspect, reason, validate, execute, verify, and recover without requiring a giant custom orchestration layer in the middle.

This is what I mean by skill logic embedded in the CLI. Not hiding complexity behind a button. Exposing the operational grammar clearly enough that an intelligent system can learn it.

Agents thrive on consistent verbs: status, list, describe, validate, apply, rollback, logs. If tools expose that kind of topology, agents generalize very quickly.

Where MCP still survives

This does not mean MCP disappears.

Enterprises still need governance, permission boundaries, audit trails, tenancy isolation, rate limits, billing attribution, compliance controls, and policy enforcement. A recursive shell-capable autonomous agent wandering through production systems is not exactly the kind of sentence compliance teams enjoy reading.

So MCP-like systems probably survive as thinner infrastructure:

Auth. Permissions. Capability advertisement. Sandboxing. Audit. Policy.

Those are real jobs. They matter. But that is different from saying MCP should be the main orchestration brain.

The more capable the agent becomes, the more orchestration moves into the agent itself and into the operational design of the tools it uses.

The architectural inversion

The old pattern was:

Application orchestrates tools for the model.

The emerging pattern is:

Agent orchestrates the environment directly.

That is the shift.

It also explains why a lot of enterprise AI platforms already feel overbuilt. Many of them are chatbot plus YAML plus governance theater. Meanwhile, the real frontier is much less glamorous: persistent agents, shell access, operational memory, recursive delegation, tool synthesis, and strong recovery loops.

That is closer to where systems like OpenClaw are headed. Not a chatbot bolted onto software, but an agent that can actually operate.

The uncomfortable SaaS implication

A lot of SaaS exists because humans needed visual coordination layers: dashboards, menus, forms, tabs, approvals, and workflows arranged for human cognition.

Agents do not care about most of that.

They care about whether the system exposes a reliable operational substrate. Can it be inspected? Can it be automated? Can it explain failure? Can it roll back? Can it prove what changed?

That means future software value may shift away from beautiful UI and toward excellent machine-operable infrastructure.

The winners may not be the flashiest AI wrappers. They may be the tools with the cleanest operational grammar.

My bet

MCP is not obsolete in the sense that nobody needs it. It is obsolete as the center of gravity.

It was useful scaffolding for a period when agents needed everything pre-modeled and fenced off. But as agents become better operators, the heavy middleware layer gets squeezed from both sides: intelligence moves upward into the agent, and skill moves downward into the CLI and tool semantics.

That feels like the real endgame:

LLM reasoning, persistent memory, a CLI-native environment, structured observability, tool discoverability, and a policy layer thin enough to govern without getting in the way.

Notice what disappeared?

Heavy orchestration middleware.

The agent becomes the orchestrator.

MCP-like systems probably survive as:

capability registries
auth brokers
governance layers
sandboxing systems

…but not as the primary intelligence layer.

The intelligence migrates upward into the agent and downward into the tool semantics simultaneously.

Which is honestly a very Unix outcome.

The ghosts of Bell Labs are somewhere smoking in approval while modern enterprise architects produce 900-slide platform decks explaining why this still needs six Kubernetes operators and a blockchain.