The next generation of interface design will not simply help people operate software. Increasingly, the software will operate alongside them.
For most of the history of digital products, the relationship between a person and a system has been relatively straightforward. A user opens an application, finds a control, provides an instruction and waits for a result.
Generative AI disrupted that model by replacing some controls with conversation. Now another transition is underway.
The interface is beginning to act.
OpenAI’s newly announced Dots are designed as always-on agents that can pursue goals across applications and continue working over time rather than waiting inside a single chat session. The company’s recent Agents API similarly emphasizes long-running systems capable of maintaining context, using tools and coordinating work across environments. Reuters
That distinction matters.
A conversational interface still behaves largely like software we already understand: the user asks, the machine responds. An agentic interface introduces persistence, initiative and delegation.
The system may gather information before the user asks for it again. It may move information between tools. It may recognize that one task depends on another. It may continue working after the visible interaction has ended.
At that point, interface design stops being primarily about screens.
It becomes workflow architecture.
That changes the design problem considerably.
Traditional UX has focused heavily on questions such as discoverability, navigation, hierarchy and interaction. Those questions remain important, but agentic systems introduce another layer: authority.
What is the system allowed to do?
What requires confirmation?
What can happen quietly in the background?
What should interrupt the user?
What information should remain visible so the user understands what the system has done?
The challenge is not simply making an intelligent system capable. It is making that capability legible.
An agent that performs twenty operations invisibly may be technically impressive and experientially terrible. Conversely, forcing a person to approve every trivial action eliminates much of the reason to use an agent at all.
The useful territory lies somewhere between those extremes.
The interface therefore becomes less like a control panel and more like a supervisory layer.
People establish objectives, constraints and priorities. Systems perform portions of the work. The interface communicates state, intent, exceptions and consequences.
That model has parallels in industrial control systems, aviation, engineering and other environments where automation has existed for decades. The technology may be different, but the central design question is familiar:
How much should the system handle, and when should the human step back in?
This is why the current wave of AI agents is more consequential than adding another assistant to another application.
The fundamental unit of interaction is changing.
A button performs an action.
A chatbot answers a request.
An agent participates in a process.
For organizations building these systems, that means experience design can no longer be considered the layer applied after the intelligence works.
The experience defines how that intelligence enters the organization in the first place.
Successful agentic systems will need clear operating boundaries, understandable histories, meaningful intervention points and interfaces that communicate what matters without turning every automated action into another notification.
The objective is not autonomy for its own sake.
It is useful delegation with accountable human oversight.
As AI moves beyond the chat window, perhaps the most important interface will be the one that quietly tells us what the machine is doing when we are no longer telling it exactly what to do.
MCS takeaway: The interface is not disappearing. Its role is changing—from operating software to supervising intelligent systems.
Visual direction: the connected workspace image represents one person overseeing a distributed system rather than sitting inside one application. The important visual idea is orchestration, not “AI.”