For nearly fifty years we’ve built software around a simple idea.
People use applications.
The interface changes. The device changes. The operating system changes. But the fundamental unit of computing remains the same: you open an application to do something.
Word to write.
Photoshop to design.
Slack to communicate.
Salesforce to sell.
GitHub to develop.
The entire modern technology ecosystem is built around that premise.
And now Microsoft seems to be asking something that until recently would have sounded absurd:
What if the application stops being the primary interface?
That’s the real story behind Project Solara.
Not the hardware.
Not the AI.
The possible death of the application as the center of the computing experience.
What Microsoft actually presented
During Build 2026, Microsoft showed Project Solara as a platform for “agent-first” devices.
Most coverage focused on the surface:
-
new devices
-
integrated AI
-
hybrid processing
-
agent-assisted experiences
But the interesting part emerges when you see how they describe the system.
They don’t talk about applications.
They talk about agents.
They don’t talk about opening software.
They talk about delegating objectives.
They don’t talk about permanent interfaces.
They talk about interfaces generated according to the task.
It might seem like a semantic difference.
It’s not.
It’s a complete paradigm shift.
The age of applications was a technological limitation
We think of applications as something natural.
Actually they were a solution.
A consequence of computer limitations.
If you wanted to edit an image you needed to open a specialized program.
If you wanted to write a document you needed another application.
If you wanted to check corporate data you needed a third.
Each problem required a different tool because computers didn’t understand intention.
They only executed specific functions.
Applications were the mechanism that connected a human need with a technical capability.
AI is starting to break that relationship.
The user no longer wants applications
The user wants results.
They always wanted results.
Applications were simply the path to get them.
No one wants to open Photoshop.
They want to edit an image.
No one wants to open Excel.
They want to answer a question.
No one wants to open Jira.
They want to know what’s blocking a delivery.
For decades we confused the tool with the objective.
Agents allow us to separate both.
The true competitor to Solara isn’t Windows
It’s the browser.
And then, the applications themselves.
Let’s look at what happened in the last twenty years.
First desktop applications were displaced by web applications.
Then web applications were encapsulated in SaaS platforms.
Now we’re seeing something different.
An agent can interact with multiple systems simultaneously.
It can query Salesforce.
Read Slack.
Update Jira.
Create documentation.
Open a pull request.
All within the same flow.
From the user’s perspective, applications start to disappear behind the agent.
They still exist.
But they stop being visible.
We’ve seen this movie before
The tech industry has a recurring tendency.
Each generation removes a layer of abstraction.
First we programmed hardware.
Then operating systems.
Then applications.
Then websites.
Then APIs.
Now agents.
Each step moves the user further from technical implementation.
And closer to intention.
The question is no longer:
What tool should I use?
The question is:
What do I want to achieve?
This completely changes how we build software
If agents become the primary interface, many design decisions change.
For decades we optimized software for human users.
Screens.
Buttons.
Menus.
Dashboards.
Navigation flows.
But an agent doesn’t need any of that.
An agent needs:
-
APIs
-
permissions
-
context
-
tools
-
structured documentation
-
consistent data models
The consequence is enormous.
Applications start competing less for visual experience and more for programmatic accessibility.
MCP could be the HTTP equivalent of this transition
There’s another reason why Solara turns out to be interesting.
It arrives exactly when the industry is building protocols to connect agents with tools.
MCP.
Agent APIs.
Tool calling.
Structured outputs.
Identity layers.
Permission frameworks.
The entire ecosystem seems to be preparing for a world where the primary consumers of software are no longer people.
They’re agents.
And that makes Project Solara look less like an isolated experiment and more like part of a much broader trend.
The future probably won’t look like what Microsoft imagines
Technology predictions rarely come true exactly.
But that doesn’t mean the direction is wrong.
It’s possible Solara will fail.
It’s possible these devices never take off.
It’s possible the hardware disappears before it consolidates.
But the question Microsoft is raising is valid.
And probably inevitable.
Because when agents can understand objectives, coordinate tools, and execute complete workflows, the need to directly interact with applications starts to diminish.
It doesn’t disappear.
But it stops being central.
The real signal
The news isn’t that Microsoft presented another AI platform.
The news is that one of the companies that built much of the modern software industry seems to be actively exploring a world where applications no longer occupy center stage.
For fifty years we learned to use computers by opening programs.
The next generation might learn to use computers by describing objectives.
And if that happens, Project Solara could end up being remembered not as a new device.
But as one of the first signs that the age of applications was coming to an end.