Salesforce shows the future without screens: AI agents lead to disposable interfaces

The familiar interface of screens, buttons, and forms is ceasing to be the primary entry point into a product. As AI agents grow, companies like Salesforce are beginning to expose functions outward through APIs, while the UI visible to the user transforms into a temporary layer that the model assembles for a specific action.

Why UI Is Changing

The trigger for discussion was the launch of Salesforce Headless 360. The company announced that Salesforce, Agentforce, and Slack can now be handed over to agents not through a browser, but directly via API, MCP, and CLI. For the system, this means a simple shift: access to data, tasks, and workflows no longer has to go through a familiar web interface.

If an agent can obtain the necessary context and execute an action on its own, a screen with buttons stops being a mandatory part of the chain. For the market, this is an important signal, because Salesforce rarely moves in a radical direction without a request from major clients. If platforms of this scale are beginning to design products not just for people, but also for agents, it means the very logic of the interface is changing.

WorkOS founder Michael Grinich describes this as an exit from the UI era, where carefully assembled screens were the main value, not the final action the user wants to achieve.

"We are exiting the UI era."

Interface On the Fly

By this logic, the interface becomes not a permanent object, but a disposable projection for a specific task. The user formulates an intention, the model receives context, and then decides which layer to show: a simple text block, a form, parameter selection, or no screen at all if the result can be returned immediately. Such a UI does not exist as a separate product artifact.

It appears at the moment of request, helps complete a step, and disappears. This also changes the role of the human. Previously, the user was an operator: clicking, navigating between screens, searching for the needed function, and manually assembling the process.

Now they increasingly become a task setter, 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, touch screens, and finally to language. Language becomes a new universal entry point into software, and the model becomes the mechanism that builds the necessary representation on the fly.

What Teams Should Do

The main takeaway for product and engineering teams sounds harsh: a beautiful screen no longer guarantees value by itself. If a user and agent can reach a result without complex UI, the winner won't be the one who draws pixels best, but the one who best packaged the product's capabilities into understandable services. This also changes the quality metric: what matters is not the number of screens, but the speed, accuracy, and accessibility of features for people and machines.

• UI is no longer a product. The product becomes capability, model, and data, while the interface merely shows the result of their work in a convenient form.

• Components are still important. The screen is no longer assembled manually for every scenario, but models still need quality elements and proper context to decide what to show the user.

• APIs become the primary surface. Agents don't need buttons for the sake of buttons: they need a reliable way to read data, execute 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.

From this follows a practical conclusion: teams will have to design the product in two dimensions simultaneously. The first is machine-oriented, where everything must be available, predictable, and safe for agents via APIs and structured data. The second is human-oriented, where the interface is needed not as a permanent façade, but as a clear temporary layer in places where it's still inconvenient without it. This is no longer a dispute between designers and developers, but a new architectural challenge.

What This Means

The next generation of software will be evaluated not by the number of screens or how carefully each click is thought out. What matters more is whether a product can quickly turn a user's intention into a result — either on its own or through an agent. For AI teams, this is a signal to reshape their thinking: capabilities, data, and APIs first, then the visual layer. Those who continue to build products as merely a collection of screens risk ending up with a beautiful interface that nobody wants to use anymore.