Article
MCP: The End of Apps as We Know Them
Model Context Protocol could weaken app silos by moving software interaction into shared conversational interfaces and clients.
The Interface Is About to Disappear
For decades, progress in software meant better buttons, cleaner layouts, and more intuitive navigation. We reduced friction from command lines to graphical interfaces, from desktop software to mobile apps.
The next reduction is more radical:
the reduction of typing and clicking itself.
Human beings do not naturally think in menus. We think in intentions.
We do not say:
“Open dropdown → filter by region → sort by price → add to cart.”
We say:
“I’m looking for a bold Italian red under $40 for dinner tonight.”
The future of tech is not more UI. It is less UI.
It is conversational.
Conversational User Interfaces (CUI) are not simply chat windows layered onto existing products. They represent a shift in abstraction. The interface moves from buttons and forms to dialogue and intent.
And Model Context Protocol (MCP) is the infrastructure layer that makes this shift durable.
MCP: The Protocol That Breaks App Silos
MCP changes where software “lives.”
Historically:
- Every tool was self-contained.
- Every app required its own login, UI, and navigation model.
- Data was locked behind product-specific interfaces.
MCP dissolves those silos.
Instead of navigating dozens of standalone apps, users will increasingly operate from within their preferred LLM client—whether that is ChatGPT, Claude, Gemini, or whatever emerges next.
The client becomes the operating system.
The tools become callable capabilities.
MCP has moved beyond a niche experiment. The official MCP documentation describes broad support across AI assistants and development tools, with a common way to connect clients to data, tools, and workflows.
That support is meaningful, but it does not make adoption automatic. Vendors still decide what to expose, clients differ in capability, and interoperability remains an implementation goal rather than a finished state.
The shift is subtle but profound:
The interface moves from product-centric to intent-centric.
The Death of the Self-Contained App
Most apps exist because users need structured workflows.
But structured workflows are simply formalized conversations.
Once an LLM client can:
- Authenticate to external systems,
- Call structured tools,
- Retrieve and transform data,
- Execute transactions securely,
The need to visit individual apps diminishes.
You no longer “go to the CRM.”
You ask your assistant to update the pipeline.
You no longer “log into your email client.”
You instruct your assistant to draft and send.
The center of gravity shifts.
Apps become service layers behind MCP endpoints.
The LLM client becomes the human-facing layer.
What This Already Makes Possible
These capabilities are not speculative. They are already state-of-the-art—just not widely adopted yet.
1. Conversational Storefronts
Imagine a wine retailer.
Instead of browsing categories, filters, and product grids, the interaction is entirely conversational:
“I want something bold, Italian, under $40, good with steak.”
The agent responds conversationally.
The visuals adapt dynamically to the context of the discussion:
- Bottles appear inline.
- Tasting notes adjust to your preference.
- Comparisons surface organically.
You never “navigate.”
You converse.
The storefront becomes responsive to intention rather than clicks.
2. Purchasing Inside Your LLM Client
Now remove even the storefront.
You remain inside your familiar LLM interface.
“Order that Barolo for delivery this Friday.”
Your LLM:
- Confirms identity.
- Checks delivery windows.
- Processes payment.
- Issues confirmation.
No tab switching.
No checkout page.
No cart UI.
Commerce becomes an extension of dialogue.
3. Email Without Email Clients
Email is an interface artifact, not a necessity.
From within your LLM client:
“Send a follow-up to the legal team summarizing today’s decision and attach the revised contract.”
The model:
- Drafts.
- Pulls the correct attachment.
- References prior context.
- Sends through your connected email provider.
The email client becomes invisible.
4. Managing Your Tool Stack from One Place
Project management, analytics dashboards, document stores, CRM systems—these exist because humans need structured coordination.
MCP allows those tools to be orchestrated conversationally.
“Show me which projects are over budget this quarter and summarize the top three drivers.”
“Create a new task for Sarah based on that risk analysis.”
“Generate a summary report for the board.”
The assistant:
- Queries tools.
- Cross-references data.
- Performs analysis.
- Executes updates.
The “app” layer becomes backend plumbing.
Why This Changes Everything
This shift has three consequences:
1. Interface Becomes Adaptive
Traditional UI is static.
Conversational UI is adaptive:
- It changes shape based on context.
- It surfaces only what is relevant.
- It removes the need for users to understand system architecture.
2. Power Concentrates in the Client Layer
When users choose their preferred LLM client, that client becomes the primary gateway to all digital activity.
Brand loyalty shifts from apps to agents.
Vendors must compete on:
- Tool reliability,
- Security,
- Interoperability.
Not on interface stickiness.
3. Abstraction Increases Again
We have moved through layers of abstraction:
- Hardware → Operating Systems
- Operating Systems → Apps
- Apps → APIs
MCP moves us to:
- APIs → Intent-Oriented Tool Orchestration
Typing and clicking are friction artifacts.
Dialogue is closer to how humans naturally operate.
The Real Question
The question is not whether MCP will succeed.
The question is whether product builders understand what layer they now occupy.
If you are building:
- Are you building an app?
- Or are you building a callable capability?
If you are designing:
- Are you designing screens?
- Or are you designing conversational affordances?
If you are leading:
- Are you optimizing UI?
- Or are you optimizing intent resolution?
The future is not a better dashboard.
It is fewer dashboards.
It is not more clicks.
It is fewer clicks.
The interface is dissolving.
And what remains is conversation.