The MS-DOS Moment
of Artificial Intelligence

The chat box is the MS-DOS of the agentic era.

"Natural language is a marvelous medium for poetry, philosophy, and casual gossip. It is an excruciatingly clumsy medium for high-dimensional spatial orchestration, continuous feedback, and parallel system steering."

When you command an autonomous AI agent through a linear chat box, you are forced into a serial, one-dimensional straw. You describe a complex, multi-agent objective—a marketing campaign, an architectural refactor, an international flight routing with four dependencies—in a paragraph of text. You press Enter. The agent vanishes into the digital ether.

Seconds later, the chat stream vomits a vertical avalanche of markdown: tool calls folding open and closed like cheap accordions, terminal logs, truncated JSON snippets, and apologies. If the agent misinterprets your intent at step three, you cannot reach in and grab the steering wheel. Your only recourse is to wait until the runaway train finishes its run, type another 200-word paragraph, and pray the model's attention mechanism doesn't suffer amnesia.

When the Model Context Protocol arrived, it was heralded as an integration renaissance: the "USB-C for AI" that would magically connect any model to every tool, database, and enterprise service on earth.

It hasn't worked out that way. Standardizing the wire format did not magically solve the integration problem.

In practice, running and orchestrating MCP servers still feels remarkably like 1980s config.sys wrangling: finicky JSON configuration files, local environment conflicts, port collisions, and silent runtime drops. Even with the July 2026 specification moving to Streamable HTTP and stateless application-level handles, the deeper friction remains untouched. The more servers you plug into a host, the more tool schemas compete for the model's finite attention, degrading reasoning and baffling tool-selection heuristics. Standardizing the pipe does nothing to eliminate semantic ambiguity, API rate limits, or upstream schema drift.

The ecosystem has made undeniable progress—unifying protocol specifications across vendors and introducing progressive enhancements like MCP Apps for inline UI components. But having a standardized cable is not the same as having a working computer.

MCP standardizes an interoperability wire, but the industry still hasn't solved the operating environment above it: how humans inspect, steer, constrain, compose, interrupt, and reverse agentic work.

Embedding an interactive form inside an auto-scrolling markdown log is still just a prettier terminal prompt. When an autonomous swarm runs, you are still watching an unspooling vertical feed. If an agent misinterprets your intent or branches in the wrong direction at step four, an inline widget does not give you a steering wheel. And when an agent acts across multiple services, the protocol wire cannot protect you without a unified, user-facing transactional model, capability sandboxing, and universal rollback semantics.

The problem is no longer the wire protocol. It is that we are attempting to run autonomous intelligence without an operating environment designed for human-agent collaboration.

If we are going to move beyond the MS-DOS era, the architecture above the wire has to change:

• Persistent spatial workspaces, not ephemeral chat widgets. MCP Apps demonstrated that services can ship interactive visual interfaces alongside headless capabilities. But rendering a disposable card inside a linear chat stream is still one-dimensional thinking. We need spatial workspaces where bimodal surfaces persist, dock, and remain directly manipulable by both humans and swarms of agents over time.
• Runtime capability discovery, out of the prompt. While modern runtimes increasingly experiment with dynamic tool filtering and routing, schemas and interface descriptions still frequently compete for context. An operating system runtime must handle discovery, capability filtering, and dynamic dispatch out-of-band—treating tools like dynamic libraries rather than prompt baggage.
• A single root of trust, not fragmented login silos. Authorization remains fragmented across many agent environments, even as MCP begins addressing enterprise access through OAuth 2.1 and centrally managed provisioning. The longer-term architectural opportunity is moving beyond per-service credentials toward OS-level capability delegation. Much like Apple Pay allows you to transact with any merchant without creating an account or handing over card details, an Agent OS must use cryptographic capability delegation. You authenticate once to your local secure enclave, define high-level policy boundaries (budgets, permissions, read/write limits), and the runtime issues ephemeral, verifiable proofs to services on your behalf.
• Universal transactional sandboxing and rollbacks. Existing agent runtimes can sandbox execution, checkpoint state, pause and resume runs, and in some environments restore entire execution environments. What they generally lack is a universal transactional model spanning heterogeneous external side effects—code changes, databases, SaaS APIs, financial transactions, physical actions—with a common inspect-before-commit and rollback semantics.
• Continuous steering and interruption primitives. Most agent interfaces still expose relatively coarse execution controls: start a run, interrupt it, or provide additional input. Fine-grained control—rewiring a dependency, changing a policy mid-run, branching from an intermediate state, or selectively replaying effects—remains poorly standardized.
• Actual interface design. Right now, the AI interface is still whatever an engineer could cobble together in an afternoon: a text prompt and an auto-scrolling log. We need designers who think in spatial layouts, glanceable status, direct manipulation, and fluid co-piloting.

The MCP ecosystem is demonstrating that substantial parts of the interoperability layer can be standardized across vendors. But standardizing interoperability is only the first step. Until we build the operating environment that lets humans and agents inspect, steer, and compose work in a shared spatial reality, we will remain trapped at the command line.