The Agent Ate the Interface

Recently, I tried to set up alerting in Grafana Cloud.

Something appeared to fail intermittently between Grafana Cloud and my deployment. The setup became stuck behind an infinite spinner. There was no useful error, no clear indication of what state the system was in, and no obvious recovery path.

A few years ago, this would have meant opening several documentation pages, searching through forum posts, inspecting network requests, repeating the setup, and eventually writing a support ticket explaining everything I had already attempted. (Just kidding, I would have given up halfway into the ordeal.)

Instead, I asked Codex to investigate.

It browsed the relevant documentation, helped me verify the likely failure, gathered the necessary context, and prepared the support request.

Grafana’s interface had still failed me. The infinite spinner was still bad UX. But it no longer blocked me in quite the same way.

An agent had become a recovery layer between me and the software.

I noticed the same shift while doing accounting work in Xero.

Xero was not necessarily badly designed. The work itself was tedious. I had hundreds of entries to navigate, inspect, classify, and reconcile. Even with a competent interface, the task demanded attention across a large number of repetitive steps.

Codex helped me design a workflow for handling them. It carried out the repetitive parts, kept me informed about its progress, and paused when an important decision required my judgment.

In both cases, I was still using the software.

But I was no longer using it alone.

That distinction may become one of the most important changes in the software industry.

For decades, software companies operated around a simple assumption: the user was a human interacting directly with the application.

The human opened the software, learned its interface, understood its abstractions, and completed a task through the paths its designers had created.

Software businesses competed intensely over this relationship.

They invested in onboarding, navigation, dashboards, design systems, keyboard shortcuts, templates, integrations, and countless small improvements intended to make the product easier and more pleasant to use.

Good UX reduced the cost of adopting a product. It allowed software to reach less technical customers. It increased engagement and retention. In crowded categories, it often became the product’s most visible competitive advantage.

That assumption is beginning to break.

The user of software is no longer always the human.

Increasingly, a person expresses an intention to an agent, and the agent translates that intention into actions across one or more applications. It navigates unfamiliar interfaces, reads documentation, fills forms, calls APIs, writes scripts, diagnoses failures, and asks the human for approval when judgment is required.

The human may still be the customer, but the agent is becoming the operator.

This does not mean UX is dead.

It means the primary interface is shifting from the application to the agent.

The application remains underneath, but the person increasingly interacts with it through a layer that can translate intent, operate the product, and recover from failure.

The cost of bad UX is changing

Bad UX still matters.

A confusing system can create errors. An ambiguous interface can hide dangerous actions. Unpredictable state can make automation unreliable. Missing feedback can leave both humans and agents unsure whether an operation succeeded.

But agents can increasingly absorb some of the cost that bad UX imposes on people.

They can search documentation without becoming frustrated. They can repeat tedious steps. They can translate cryptic terminology. They can compare the current screen with expected behavior. They can help users recover from failures that would otherwise cause them to abandon the task.

This weakens a long-standing software moat:

Our product wins because it is easier to use than the alternatives.

Ease of use remains valuable. But it may become less decisive when an agent performs the difficult parts.

A product with an awkward interface but predictable behavior may remain perfectly usable through an agent. Meanwhile, a beautiful application with inconsistent state, weak permissions, and poor error handling may become difficult to automate safely.

The definition of good software begins to change.

For a human-operated application, good UX often means clarity, speed, consistency, and delight.

For agent-operated software, it also means structured state, stable interfaces, explicit permissions, reversible actions, inspectable results, and reliable feedback.

The application does not merely need to be easy to use.

It needs to be easy to understand and operate programmatically, even when the program is an agent navigating it dynamically rather than a traditional integration following a predefined path.

Tedious software becomes less visible

The Xero example points toward an even larger change.

Some software is difficult not because the interface is bad, but because the underlying work is repetitive.

Accounting requires reviewing transactions. Customer support requires processing requests. Sales operations requires updating records. Compliance requires checking documents. Infrastructure work requires configuring systems and investigating failures.

Software improved these jobs by organizing information and providing tools for performing each step.

But the human still had to operate the process.

Agents can begin to absorb the process itself.

Instead of opening Xero and manually working through hundreds of entries, I can describe the intended outcome, let an agent propose a process, and intervene only when necessary.

The software has not disappeared. Xero still holds the records, enforces accounting rules, maintains the audit trail, and provides the underlying system of record.

But from my perspective, more of the application becomes invisible.

I am no longer paying attention to every screen, field, and navigation path. I am paying attention to the decisions and the result.

This may be where much of business software is heading.

People will not necessarily become more proficient users of increasingly complex applications.

They may stop operating those applications directly.

The interface is where the value lived

This creates a difficult problem for SaaS companies.

For much of the SaaS era, the application interface was not merely a way to access the product. It was where the company captured value.

The interface trained the customer to think in the product’s abstractions.

Airtable taught users to organize work through bases, tables, records, and views.

Salesforce taught organizations to model customer relationships inside its objects and workflows.

Grafana taught operators to think through dashboards, data sources, alerts, and panels.

Xero taught businesses to carry out their accounting work through its reconciliation and reporting systems.

Once customers learned these abstractions and organized their operations around them, the product became difficult to replace.

The interface created familiarity, habit, and switching cost.

Agents weaken that relationship.

An agent can learn the abstractions on behalf of the user. It can translate ordinary language into the concepts expected by each application. It can operate several products without requiring the person to become fluent in all of them.

Some of that fluency can be packaged into a skill: reusable instructions and references that teach the agent an application’s vocabulary, preferred workflows, and the points where it should stop for approval.

The user no longer has to think like Airtable, Grafana, Xero, or Salesforce.

The agent does.

That means the application risks losing direct ownership of the customer relationship.

The person may spend most of their time inside Codex, Claude, ChatGPT, or another agent environment, even while continuing to depend on a large collection of SaaS products underneath.

The model provider or agent harness becomes the primary interface.

The SaaS product becomes an execution environment.

Software categories begin to compress

This is also why AI may compress software categories.

The traditional software market divided work into increasingly narrow products.

There were applications for forms, databases, automation, dashboards, customer management, internal tools, project management, reporting, documentation, support, and hundreds of more specialized functions.

Each product justified itself through a combination of features, usability, and integrations.

But agents operate above these boundaries.

A single agent can collect information through a form, update a database, call an internal tool, reconcile a record, produce a report, and notify the relevant person.

The underlying systems still exist, but the user experiences them as one continuous workflow.

From the user’s perspective, several applications begin to collapse into a single conversation or task.

This does not necessarily mean one agent will replace every SaaS product.

Systems of record still matter. Permissions matter. Auditability matters. Domain-specific rules matter. Reliable infrastructure matters.

But many products may become thinner.

Their visible interface becomes less central. Their standalone features become easier to reproduce. Their workflows can be coordinated from outside the product.

They move downward in the stack.

What was once a destination becomes a capability.

What was once an application becomes infrastructure.

The SaaS reset

This is why the recent news around Airtable, Relay.app, and Flowise feels relevant, even if none of it proves the argument.

Airtable was one of the defining products of the SaaS era. It combined the accessibility of a spreadsheet with the structure of a database and the flexibility of an internal-tool platform.

In 2021, Airtable raised $735 million at an $11 billion pre-money valuation. In August 2026, Bending Spoons agreed to acquire it for $1.29 billion in cash; Axios reported an implied equity value of $2.25 billion after including Airtable’s cash and cash equivalents.

That is a striking reset. It is not an explanation.

The discussion on Hacker News reflects the uncertainty. Some readers blamed AI substitution. Others pointed to overfunding, operating costs, conventional competitors, or Bending Spoons’ acquisition model. The public deal does not tell us which explanation is right.

Relay.app presents a different signal. It built a polished automation product that customers described as easy and reliable. Yet Relay has announced that it is shutting down, leaving customers to discuss where to move their workflows.

Relay did not disclose why it is closing, so its shutdown cannot fairly be attributed to agents.

Flowise did. The open-source workflow builder is winding down barely a year after Workday acquired it, and its team named the cause plainly: developers are moving complex work to coding agents, and a rigid low-code workflow builder “quickly hits the limit.”

Even OpenAI is retiring its own Agent Builder this November, steering builders toward its Agents SDK and ChatGPT agents instead.

What these events do show is narrower: a useful product with strong UX is not automatically a durable standalone business. Agents add another source of pressure by weakening ownership of the interface, reproducing parts of workflows, and coordinating capabilities that previously required separate applications.

That pressure is real. Airtable and Relay make it visible without settling its cause. Flowise names it outright.

The new walled gardens

The old software industry was dominated by application platforms.

Microsoft controlled the operating system and office suite. Apple controlled its devices and app distribution. Google controlled search, advertising, and much of the web’s discovery layer.

The emerging walled gardens may be the model providers and agent harnesses.

They control the point where the user expresses intent. They decide which tools are available to the agent, how those tools are presented, what context the agent can access, and which applications it chooses to use.

That control is not incidental. The harness can materially change the capability the user experiences, even when the underlying model remains the same.

When the user asks an agent to complete a task, they may not care which specific service performs every step. They care that the task is completed reliably.

The software provider still supplies the capability, but the agent provider owns the interface, the context, and increasingly the distribution—another way software value may shift toward foundation-model providers.

We have seen this pattern before.

Businesses that depended on search traffic eventually had to optimize for Google.

Businesses that depended on mobile distribution had to optimize for Apple and Android.

Software companies may now have to optimize for agents.

What software still has to do

I do not know which software moats will prove durable in an agentic market. Airtable’s valuation reset and Relay’s shutdown cannot answer that, and listing the familiar defenses—data, network effects, trust, distribution—does not make them durable by default.

What is clearer is that important software will still need to adapt.

The records have to live somewhere. So does the learning loop through which people and institutions turn those records into better judgment.

Xero still holds the authoritative state, applies accounting rules, and preserves the audit trail even when an agent performs much of the work. But as the human becomes the reviewer and the agent becomes the operator, the value of that software shifts toward being a reliable system of record and control.

Software in an agentic world must expose clear state and explicit permissions. Consequential actions should be auditable and, where possible, reversible.

The next generation of UX may be less about arranging pixels and more about arranging state and authority.

That means making clear what the system records, what the agent can change, what requires approval, and what a human can inspect or undo.

These are interface questions, even when the interface is no longer primarily graphical.

The agent ate the interface

AI does not just create new software.

It changes the assumptions that made an entire generation of software companies valuable.

The SaaS era rewarded companies for owning the place where work happened. They built interfaces, accumulated features, and taught customers to organize their operations around proprietary applications.

Agents are beginning to sit above those applications.

They absorb complexity, operate several tools at once, work around imperfect UX, and translate human intent into product-specific actions.

The software underneath does not disappear.

But it becomes less visible, less differentiated, and potentially less valuable as a standalone destination.

The golden age of SaaS was built on the idea that every important workflow would become an application.

The agentic era may reverse that assumption.

Every application becomes a tool inside a larger workflow controlled somewhere else.

For decades, software companies competed to own the interface through which people worked.

Now the agent is eating it.