SaaS Was Built for Users. What Happens When There Aren’t Any?

So far the tl;dr of this series is: Interfaces are fading. Agents are rising. And SaaS, as we know it, isn’t ready.

Because SaaS  - like, well… the entire internet… was built for users. Clickers. Viewers. Humans who log in, look around. Do A Thing.

But what if the user isn’t the one doing the using anymore?

That’s where the SaaS funnel starts to come apart at the seams.

From Platform to Protocol

For the past decade at least, SaaS services have been hell-bent on becoming a place. A platform that you log into and conduct your business. Somewhere to log in, hang about, mess around in dashboards and plug into other platforms with APIs (more on those in a moment). Much like social media, SaaS wants you to spend more time with them. 

But in our Agentic Future, platforms are giving way to protocols.

Your product is no longer the destination. It’s a callable function inside someone else’s workflow. Or more likely, inside an agent’s workflow.

This isn’t theoretical either. Calendly, Reclaim, Zapier, Notion AI. Are of those are callable units. Scheduling happens because an agent decided it should happen. A meeting is booked, a task is created, a note is summarised. No UI required. Which also means no human necessary.

Your tool doesn’t need to be beautiful. It needs to be composable. Reliable. Well-documented. Accessible by other systems.

In an agent-first world, SaaS becomes infrastructure. Less product. More protocol.

The Death of the Dashboard

Dashboards were built for humans. Agents don’t need charts.

Log in, see the metrics, build a report. Unless you’re an agent. In which case you… ingest. Query. Summarise.

The classic SaaS loop of onboarding, usage, engagement, and retention breaks when there’s no one doing the clicking.

Dashboards become internal scaffolding, and the real UX moves upstream. The report lands in Slack. The alert fires. The task gets closed.

Which means your beautifully designed interface might never be seen.

But your data structures will be.

Because what still matters is clean, accessible, structured data. Standardised outputs. APIs that behave themselves. Interoperability that doesn’t make your dev team weep.

Which means your entire approach to design needs to change. Because agents are after legibility, and they don’t care about showmanship. 

Agents as Buyers and Users

So what happens to the procurement process? Is it now just another prompt? Sort of. 

The AI agent does the shortlist. Another agent handles integration. Maybe no human ever touches the thing until it breaks (and it inevitably will). 

Monty, G2’s AI recommender, already parses reviews and specs to suggest vendors. Buyers ask it questions in plain English. It replies with ranked suggestions. Somewhere in there, your product is being judged. Not by a person. By a parser. And this is in people’s inbox right now. Which means it’s in their purchase decisions right now. 

So instead of crafting lilting prose for a user, you’re just making sure a system can read it. 

As I mentioned in earlier articles, that means structured metadata, parsed feature lists, pricing tables in plain text. And Schema.org might be your new conversion layer.

And reviews? Think less persuasive anecdote. More verifiable input signal.

You’re still being sold. But the buyer has changed.

Invisible Value and the AIX Imperative

If nobody sees your product, how do they know it works?

We’re back on the Agent Interface Experience boat again. 

Forget microinteractions. Agents want predictability. Structured outcomes. Uptime. Legibility. Logging.

What used to be UX polish is now API versioning. What used to be product tours is now sandbox testing. What used to be intuitive is now machine-readable.

AIX is about trust. Not vibes. And trust for a machine is very different from the type of trust you might build (or try to build) with a human. Ultimately, all marketing boils down to trust - do I think you’ll deliver. The machine thinks the same way. But rather than a firm handshake, it’s relying on millions of schematic signals. 

Expose your endpoints. Define your outputs. Make your product understandable. First by  systems, then humans.

What Still Needs a Human

Strategy. Risk. Accountability. Exceptions.

Agents are great at doing. Humans are still required for deciding (and for cleaning up when things go sideways - and, again, they will).

So yes, design for agents. But don’t forget the human checkpoints: audit trails, escalation paths, preferably a huge red button that says “stop.”

Most new systems don’t need babysitting, but they do need to be understood, and occasionally stopped when they go rogue or stop making sense. 

Legibility builds trust. Visibility meanwhile, keeps us sane. (@Growstack have a good article on this that’s worth a read - because visibility isn’t just about oversight in these cases. It’s often about ethics as well.)

The Attribution Blackout (Again)

Remember the first dark funnel? Say hello to its goth cousin.

No demo requests. No campaign attribution. No MQLs in HubSpot (and a totally different type of HubSpot for that matter).

Your product got discovered, shortlisted, integrated… and you had no idea.

Because the discovery happened inside a closed loop: A chatbot,  procurement agent,  Slack message, whatever. There’s no following a trail you didn’t even know existed, let alone measuring it.

So rather than optimising for engagement, we need to think about optimising for pure inclusion, and inclusion has an entirely different set of metrics (and, be honest, how many of us can really say we had the engagement metrics down in the first place?). Agent queries, API triffic maybe structured signals from unknown sources - these are what we’ll need to watch. 

Which means you might need new metrics: agent queries, API traffic, structured signals from unknown sources.

Goodbye CTR. Hello ‘ambient discoverability’*. *at some point I’ll sit down and come up with less cringey terms for all this. ‘Rotating recognition’ is my current fave. 

Risks, Edge Cases, and Objections

Not everyone’s buying this.

Again, we mentioned this earlier, but it’s true: Some people still want interfaces. I like pressing buttons and applying filters. I like staring at little charts to see why traffic from Kuwait went up last tuesday. It’s not wrong to want this.  

Also: agents still hallucinate. They do weird things. They might break your workflows (or get your team fired, or make up citations in your national health report. 

So agent validation needs to become part of your product model. Logging is now for audits as well as debugging, and explainability isn’t optional. We haven’t even got into onboarding. But instead of walkthroughs and explainers, agents will need config files, templates, metadata and prompt engineering. (Yes, sorry.)

This shift is already very real, and so are the risks. Which means:

Design for the agent, but make it safe for the human. Or if you want to be poetic about it, build a system that works in the shadows but makes sense in the light.

The New B2B Playbook

As with all evolutions, this isn’t the death of anything big. It might mean less stime staring at laptops, but B2B SaaS without screens will still have software. But it does mean that service is changing.

You’re not designing for clicks. You’re designing for calls. Invocations. Inclusions.

The iPhone is (probably) the defining consumer product of the century so far. Like the iPod before it, it had a much better interface than anything that preceded it. But going forward, it’s not about the best interface for fat-fingered consumers (or indeed, fat-fingered data analysts*). It’s about the best interface for other systems. 

*Slim-fingered analysts and consumers are also available.