Salesforce shows a future without screens: AI agents point to disposable interfaces

The familiar interface of screens, buttons and forms is no longer the main entry point to a product. As AI agents grow, companies like Salesforce are starting to expose functions through APIs, while the UI the user sees becomes a temporary layer that the model assembles for a specific action.

Why the UI is changing

The trigger for the discussion was the launch of Salesforce Headless 360. The company announced that Salesforce, Agentforce and Slack can now be exposed to agents not through the browser, but directly through API, MCP and CLI.

For the system, this means a simple shift: access to data, tasks and workflows no longer has to pass through the familiar web interface. If an agent can get the context it needs and perform the action itself, a screen with buttons is no longer a mandatory part of the chain.

For the market this is an important signal, because Salesforce rarely moves first in a radical direction without pressure from large customers. If platforms of this scale start designing products not only for people but also for agents, the very logic of the interface is changing.

WorkOS founder Michael Grinich describes this as an exit from the UI era, in which the main value was a carefully built screen rather than the final action the user wants to get.

"We are leaving the era of UI."

Interface on the fly

By this logic, an interface becomes not a permanent object but a disposable projection for a specific task. The user states an intent, the model receives context, and then decides for itself which layer to show: a simple text block, a form, a choice of parameters, or no screen at all if the result can be returned immediately.

Such a UI does not live on as a separate product artifact. It appears at the moment of the request, helps complete a step and disappears.

This also changes the role of the human. Previously the user was an operator: clicking, moving between screens, hunting for the right function and assembling the process by hand. Now the user increasingly becomes the one who sets the task, then an editor and ultimately a director for the agent.

Grinich links this shift to the evolution of interfaces, from switches and commands to cursors, touchscreens and, finally, language. Language becomes the new universal entry point into software, and the model becomes the mechanism that builds the needed view on the fly.

What teams should do

The main message for product and engineering teams is blunt: a beautiful screen no longer guarantees value on its own. If the user and the agent can reach a result without a complex UI, the winner will not be whoever draws pixels better, but whoever packages the product's capabilities into clear services better.

This also changes the quality metric: what matters is not the number of screens but the speed, accuracy and availability of functions for people and machines.

• The UI is no longer the product. The product is the capability, the model and the data, while the interface merely shows the outcome of their work in a convenient form.
• Components still matter. A screen is no longer assembled by hand for each scenario, but the model still needs quality elements and the right context to decide what to show the user.
• APIs become the main surface. Agents do not need buttons for the sake of buttons: they need a reliable way to read data, trigger actions and return results.
• The model itself becomes the interface. The fewer unnecessary switches, menus and steps, the lower the cognitive load and the faster a person reaches the desired outcome.

A practical conclusion follows: teams will have to design a product on two planes at once. The first is the machine plane, where everything must be accessible, predictable and safe for agents through APIs and structured data. The second is the human plane, where the interface is needed not as a permanent facade but as a clear temporary layer in places where it is still inconvenient without one.

This is no longer a dispute between designers and developers, but a new architectural task.

What this means

The next stage of software will be judged not by the number of screens or by how carefully every click is thought out. What will matter more is whether a product can quickly turn a user's intent into a result, either by itself or through an agent.

For AI teams, this is a signal to rethink their approach: capabilities, data and APIs first, the visual layer second. Those who keep building a product only as a set of screens risk ending up with a beautiful interface that nobody wants to work through anymore.