Source: Unsplash
The SaaS interface as we know it is dying. AI agents are becoming the primary consumers of software, not humans, and that single shift is breaking every assumption product designers have worked from for the last two decades. In this article I break down what Agent Experience (AX) design actually means, why the transition is accelerating faster than most teams realize, and the concrete steps product designers need to take right now to stay relevant.
I've been shipping products for over eight years. In that time the core job of a product designer barely changed: figure out what humans need, reduce friction, make the interface intuitive enough that people don't have to think. Clean up the nav. Test the onboarding flow. Iterate on the dashboard until retention improves. That was the work.
Then, somewhere between late 2024 and right now, the user changed. Not the persona, not the segment. The actual user. A growing share of the people interacting with SaaS products today are not people at all. They're AI agents, and they don't care about your carefully crafted hover states or your onboarding tooltip sequence. They're reading your API surface, parsing your semantic HTML, and deciding in milliseconds whether your product is usable or not. That's a completely different design problem.
"Forrester declared 'SaaS as we know it is dead.' The catalyst was Anthropic's release of agentic capabilities on February 3rd, which the market interpreted as a direct threat to the per-seat SaaS model. Product teams have started calling it 'Black Tuesday for Software.'"
— Forrester Research, early 2026
The Numbers Behind the Shift
This isn't speculation. The data is already here, and it's moving fast. Gartner projects that 40% of enterprise applications will integrate task-specific AI agents by the end of 2026, up from less than 5% just a year ago. That's not a gradual adoption curve. That's a cliff edge.
Deloitte's forecast is even sharper on the economics. The agentic AI market sits at $8.5 billion in 2026 and is on track to hit $45 billion by 2030, growing at a 53% CAGR. When markets grow that fast, they don't ask permission from incumbents. They just replace them. Meanwhile, 31% of new SaaS products launching this year will ship with a conversational interface as the primary input method, up from 12% in 2024. That's more than double in two years.
And here's the stat that I keep coming back to: Salesforce's State of the Connected Customer report found that 73% of B2B buyers now expect software interfaces that adapt to their role, behavior, and prior actions. That was 41% in 2022. The expectation gap between what users want and what most SaaS products deliver is widening by the quarter. AI agents are filling it.
What AX Actually Means (and Why UX Alone Won't Cut It)
The term Agent Experience (AX) was coined by Netlify CEO Matt Biilmann, who defined it as "the holistic experience AI agents will have as the user of a product or platform." When I first heard that framing I'll be honest, it felt abstract. Then I started actually building for it, and the gap between UX and AX became impossible to ignore.
Traditional UX is about visual hierarchy, animations, emotional resonance. You're guiding a human through a flow, meeting them where they are cognitively, reducing mental load. AX is something fundamentally different. When an AI agent interacts with your product, it needs semantic clarity, predictable structure, and explicit action schemas. It doesn't notice your design system. It reads your DOM. It parses your API. It decides what's possible based on how well you've described your surface.
John Maeda's Design in Tech Report 2026 called this the transition from UX to AX, framing it as the most significant structural change to the design discipline since mobile. He's right. The discipline is splitting. You'll have HX designers focused on human-centered interfaces, and AX designers focused on machine-to-machine interfaces. Both matter. Most product teams are only staffed for one.
via GIPHY
Why the Traditional SaaS Interface Is Becoming Legacy Infrastructure
Here's what I see happening across the products I work on and the products I advise on. The interface layer, the dashboards, the nav menus, the settings panels, those things were designed for one purpose: to let humans operate backend logic through a visual translation layer. That translation layer made sense when humans were the only operators.
AI agents don't need it. They interact with your system through APIs, through MCP servers, through structured schemas. And the numbers tell that story clearly. MCP server downloads grew from 100,000 to 8 million in five months. There are now over 10,000 active public MCP servers and 97 million monthly SDK downloads across Python and TypeScript. The protocol that Anthropic introduced in November 2024 has become the de facto standard for connecting AI agents to products and data. OpenAI, Google DeepMind, and Microsoft are all on board. The Linux Foundation now governs it under the Agentic AI Foundation, making it truly vendor-neutral infrastructure.
The SaaS products that survive this decade won't be the ones with the best interfaces. They'll be the ones that are easiest for AI agents to operate.
That doesn't mean visual interfaces disappear. Humans still need them. But increasingly, the human interface becomes a configuration layer, a review layer, a trust layer, while agents handle execution. The product architecture flips. Instead of designing for a human who uses your product all day, you're designing for a human who reviews what an agent did on their behalf. Those are very different design problems, and very different success metrics.
What AX Design Actually Requires: A Practical Breakdown
I've been working through this shift in my own practice and these are the things that actually matter when you're designing for agents:
- Semantic HTML and clear DOM structure. Agents parse your markup. If your component hierarchy is a mess of divs with no semantic meaning, agents can't reliably interpret or interact with it. Clean semantic structure isn't just an accessibility win, it's a prerequisite for agent usability.
- Explicit action schemas. Your product needs to clearly expose what actions are possible and how to invoke them. Think of it as the agent equivalent of affordances. A human sees a button and understands it's clickable. An agent needs a schema that says this action exists, here's what it accepts, here's what it returns.
- API completeness. Every action a human can take through the UI should also be possible through the API. If your UI does something your API doesn't support, you've built a dead end for agents. I see this constantly in products that were built UI-first without thinking about programmatic access.
- Audit trails and explainability. When an agent takes action in your product, humans need to understand what happened and why. This is a design problem. You're not just logging events, you're designing a narrative layer that lets humans maintain trust and oversight of agent behavior.
- Trust surfaces. Where do humans step in? What requires human confirmation? These aren't just engineering decisions. They're experience design decisions. Getting them wrong, either requiring too much human intervention or too little, destroys the value of the agent entirely.
- Graceful degradation. Your product needs to handle partial agent instructions, ambiguous requests, and failure states without breaking. Agents make mistakes. The design question is what happens when they do.
What This Means for Product Designers Right Now
I want to be direct about this because I've seen a lot of takes that are either too alarmist or too dismissive. The product designers who will struggle in the next three years are not the ones who don't know how to use AI tools. They're the ones who only know how to design for humans.
The skill gap is real. Most design programs don't teach API design thinking. Most design portfolios show zero evidence that the designer understands how agents interact with their products. That's going to matter more and more as hiring teams start asking for it.
What I'm doing personally: I've started treating every product I work on as having two user types, the human and the agent. I ask myself both questions in every design review. What does the human need from this? And what does an agent need to successfully operate this without human help? Those two questions produce very different design decisions, and holding them both at once is the actual skill.
The good news is that strong UX foundations transfer. If you understand mental models, task flows, and system design, you already have most of what you need. The delta is understanding how agents perceive and interact with software, and that's genuinely learnable. I've written more about building AI-native products over on my Medium and at reloadux.com/blog if you want to go deeper.
The shift from UX to AX is not coming. It's here. The question is whether your design practice is evolving alongside it.
Are you already designing for AI agents in your products? Drop a comment below. I'd genuinely like to know what you're running into, what's working, and what's completely broken. The more we share from the field on this, the faster we all figure it out.
Sources: Gartner Enterprise AI Agents Forecast 2026, Deloitte Technology Media Telecom Predictions 2026 (SaaS AI Agents), Forrester SaaS Research 2026, Salesforce State of the Connected Customer 2025, John Maeda Design in Tech Report 2026, Linux Foundation Agentic AI Foundation announcement, Stratpoint AX Design Report May 2026, Netlify CEO Matt Biilmann on Agent Experience (AX)