MCP and code execution are moving software from menus to intent

Imagine never clicking another dropdown menu. No more hunting through settings tabs. No more learning where some designer decided to hide the feature you need.

You just say what you want, and it happens.

That's the direction a lot of people think computing is heading, and the plumbing for it is already being built. Former Google CEO Eric Schmidt put it bluntly: "I think user interfaces are largely going to go away."

I think he might be right, with some big caveats. Here's why.

The 50-year-old GUI model that's finally breaking

The way you interact with computers today, windows, icons, menus, and a pointer (WIMP), was invented at Xerox PARC in 1973. Apple popularized it with the Macintosh in 1984. Microsoft brought it to the masses with Windows.

That was 50 years ago, and we're still using pretty much the same interaction model.

Eric Schmidt recently asked: "Why do I have to be stuck in what is called the 'WIMP' interface, Windows, Icons, Menus, and Pulldowns, that was invented in Xerox PARC 50 years ago?"

It's a fair question. The WIMP desktop model has real limitations that become more obvious as software grows more complex:

The GUI was revolutionary in 1984. But we've been patching the same desktop model for half a century.

The fundamental shift: from "how" to "what"

Here's the core change happening right now:

Command-based computing (old model): You tell the computer how to do something. Click File -> New -> Spreadsheet -> Format -> Add Column -> Name it "Revenue"...

Intent-based computing (new model): You tell the computer what you want. "Create a spreadsheet tracking monthly revenue by product line."

That flips the human-computer relationship around. It's a bigger change than a UX tweak.

SAP's Chief Design Officer Arin Bhowmick describes it as evolving "into systems of intent and outcome where the back end will be able to derive the intent of the users and get the work done."

Here's the difference in one table:

Instead of learning where buttons are, you describe what you need. Instead of orchestrating tools yourself, agents orchestrate them for you.

Why this is happening now

Several things had to converge for this shift to become practical.

1. Language models that actually understand intent

Large language models can now parse natural language instructions with enough accuracy to be useful. "Find all invoices over $10,000 from Q3 that haven't been paid" is no longer a fantasy query. It's something Claude, GPT-4, or Gemini can translate into actual database operations.

Five years ago this wasn't possible. The models weren't good enough.

2. A universal protocol for tool access (MCP)

The Model Context Protocol, released by Anthropic in late 2024, solved the integration problem. Before MCP, connecting an AI to your tools meant custom code for every integration. MCP standardizes this: write one server, and any AI can use your tool.

The adoption has been fast:

• OpenAI adopted MCP, starting with its Agents SDK (March 2025)
• Microsoft added MCP support to Windows 11 (May 2025)
• Google DeepMind built native MCP support into Gemini
• 10,000+ public MCP servers now exist

MCP is becoming the "USB-C for AI": a universal connector between agents and capabilities.

3. Code execution that makes it efficient

But the original MCP approach had a problem. Loading all tool definitions upfront ate a lot of context (55,000+ tokens for just 58 tools). That's a big slice of your AI's working memory, gone before you've typed anything.

Cloudflare and Anthropic both landed on the same fix: let agents write code instead of calling tools directly. The AI generates TypeScript that orchestrates the tools, runs it in a sandbox, and returns only the results.

The result: a 98.7% reduction in token usage, according to Anthropic's benchmarks.

That's the change that makes agents affordable to run across many tools.

What "Zero UI" actually looks like

The industry calls this direction "Zero UI": interfaces that need little to no visual interaction. The name is a bit misleading, because the interfaces don't vanish. They change shape and become:

Ephemeral: Generated on-demand for your current task, then gone. No permanent buttons or menus.

Contextual: The system knows what you're doing and surfaces only relevant options.

Conversational: You interact through natural language, not navigation hierarchies.

Predictive: The system anticipates needs before you articulate them.

Here's a concrete example of the shift:

Old way (WIMP):

1. Open travel booking site
2. Click "Flights"
3. Enter departure city
4. Enter destination
5. Select dates
6. Click "Search"
7. Filter results
8. Select flight
9. Enter passenger details
10. Enter payment info
11. Confirm booking
12. Repeat for hotel, car, restaurant reservations...

New way (Intent-based): "I'm going to New York this weekend for a client meeting. Book flights, a hotel near their office, and dinner reservations for Friday night. They like Italian."

The agent handles all 30+ steps across multiple services. You review and approve the plan.

Gartner predicts that by 2028, 70% of customer journeys will occur entirely through AI-driven conversational interfaces.

The technical layer: how MCP enables this

MCP works as a client-server protocol. Your AI assistant is the client. External tools (databases, APIs, services) expose MCP servers.

Execution flow:

1. User intent -> Assistant receives high-level prompt
2. MCP discovery -> Assistant discovers tool schemas across connected MCP servers
3. Orchestration -> Agent writes unified code instead of chained tool calls
4. Sandboxed execution -> Script executes in an isolated environment
5. Review -> Consolidated output is delivered for final approval

The key insight: agents don't call tools one by one (slow, token-heavy). They write a program that orchestrates multiple tools, execute it in a sandbox, and return the results.

That's why Cloudflare's team concluded: "LLMs are better at writing code to call MCP than at calling MCP directly."

What happens to traditional software?

If agents become the primary interface, the SaaS model has a problem.

Traditional SaaS depends on users logging into your app, learning your interface, spending time clicking through your features, and returning to your dashboard.

Agentic computing skips all of that. The agent gets the task done without ever showing your UI. Users might not even know which services are being orchestrated behind the scenes.

The value shifts from "interface to accomplish X" to "capability to accomplish X." For routine tasks, your API starts to matter more than your UI.

Salesforce sees this coming: "We're at the beginning of a major transformation in which autonomous AI agents will become the new user interface."

Some predictions:

The agentic operating system

An essay from Serious Insights argues that Windows, macOS, and Linux will become "legacy interfaces" within 3-5 years. They'd keep working. They'd just matter less.

The argument: when your primary computing relationship is with an orchestration layer (an AI that remembers context, explains options, and executes on your behalf), the underlying OS becomes an implementation detail.

Microsoft seems to see it the same way. At Build 2025, it introduced:

• MCP as a foundational layer in Windows 11
• "Ask Copilot on the taskbar", a unified entry point for agents
• "@" mentions to invoke agents directly from the taskbar
• Agent permissions managed at the OS level

My read: they want to own the orchestration layer.

Why this won't be instant

This transition has real challenges:

Trust and reliability: Agents are probabilistic. The same input might give slightly different outputs. A CFO closing quarterly books needs deterministic results. Agent-generated workflows can't guarantee that yet.

Carnegie Mellon research found that in simulated company environments, no agents could complete a majority of assigned tasks. A great demo isn't the same as a reliable worker.

Security: When agents can act on your behalf (running code, sending emails, making purchases), the attack surface grows a lot. MCP vulnerabilities identified in April 2025 include tool poisoning, prompt injection, and cross-server shadowing.

The "lowest common denominator" problem: MCP abstracts away differences between tools. But abstraction means losing tool-specific features. Not everything can be reduced to a universal interface.

User control: When things go wrong in a GUI, you can see what happened and fix it. When an agent orchestrates 15 services to accomplish your request, debugging becomes harder. Transparency and auditability aren't solved problems.

What won't disappear

The GUI won't completely vanish. Just as the command line didn't disappear when GUIs arrived, some use cases will remain:

• Creative work: Design, video editing, and art creation need direct manipulation
• Data exploration: Visualizing and discovering patterns in data benefits from interactive charts
• Precision tasks: Surgical tools, CAD software, and audio engineering need fine-grained control
• Learning and discovery: Sometimes you don't know what you want until you see the options

The GUI becomes a specialized tool rather than the default interaction mode. You use it when you need direct control, not for routine tasks.

The timeline

Now (2026):

• MCP adoption accelerating
• Code execution making agents practical
• Early "agentic-native" apps appearing

Near-term (2027-2028):

• Agent-to-agent communication standards (Google's Agent2Agent protocol)
• OS-level agent permissions and sandboxing mature
• First applications with no traditional UI at all

Long-term (2030+):

• Traditional GUIs become accessibility/power-user features
• Natural language as primary computing interface
• The meaning of "using a computer" fundamentally changes

The interface inversion

The Mac made the command line optional, a power-user tool rather than a requirement. Now something similar is happening to the GUI.

For 50 years, we've adapted to software. We learned menu structures, memorized shortcuts, navigated hierarchies designed by people who aren't us.

That's starting to flip. Software is learning to adapt to us.

MCP provides the plumbing. Code execution makes it efficient. Language models provide the understanding. Together, they make computing that responds to intent, not just commands.

Takeaways

• If you build software, treat your API as a product. Agents may end up using it more than people use your menus.
• Keep the GUI for direct control: creative work, data exploration and precision tasks.
• Don't hand agents destructive tools until trust, security and auditability catch up.

Eric Schmidt might be right that user interfaces, at least as we've known them, are going away. Screens will stay. What's becoming optional is clicking, typing and navigating your way through software by hand.

Resources

• Zero UI: the invisible interface revolution - Microsoft's analysis
• The end of traditional UI - Why the 50-year desktop UI model is ending
• Anthropic: code execution with MCP - The 98.7% efficiency breakthrough
• Cloudflare: code mode - Why LLMs are better at writing code than calling tools
• MCP went sideways - Critical analysis of MCP's evolution
• The agentic operating system - Why traditional OSes become legacy
• Model Context Protocol specification - Official spec
• WIMP computing - History of the desktop interface we are moving past