Your Next Customer Might Never See Your UI

With every new project, I come back to the same question: “Do I still need UI?“

I see a shift coming where the purpose of UI is primarily to see and understand the state of the system… But very rarely to take action. I am a strong believer that straight line actions are better run by agents. AI can do your job… what now?

As Laurie and I build Always Curious, our focus is sharpening lean project management and communication hygiene. I believe realized efficiency comes from carving out margin by eliminating the constant context-switching and swivel-chair actions that clutter daily execution. The holy grail is a unified point of interaction, a shift that feels increasingly imminent. While early SaaS promised cost-effective expertise, it ultimately fragmented into niche micro-SaaS apps, leaving users bouncing between tabs just to handle basic tasks.

I recently spent time with practitioners discussing the future of SaaS among founders, operators, and technical buyers, the people closest to this shift. What I keep finding is the market arguing with itself. The argument is worth hearing in full, because I believe both sides are right from their perspective.

The claim

Almost every B2B SaaS company right now is building the same thing: a proprietary AI assistant inside their web app. Log in, open the sidebar, talk to the bot.

The buyers are moving somewhere else. They want to stay in Claude Code, Codex, or their terminal, and have their central agent talk to your product through APIs, MCP servers, or plain execution hooks. Nobody wants fifteen walled gardens with fifteen chatbots in fifteen tabs.

If that continues, two things follow. If a customer cannot invoke your core capability from their existing agent, they will pick a competitor whose API is easier to hook into, or they will script a lightweight internal tool themselves. Your UI stops being the product. Your capability layer is the product.

And outbound has to change too. Pitching another standalone tool with its own login screen faces what one practitioner called “massive fatigue.” The people getting traction use reasoning models upstream to catch live timing signals, like a stack migration in progress or a workflow that is actively breaking, and reach out at that moment. The AI qualifies the timing. The human writes the email.

The pushback, which is not wrong

The skeptics in the discussion made four arguments that I believe we should take seriously.

First, most people do not have experience with agents outside of the chat box and cannot use harnesses easily yet. Driving an AI agent well is an advanced-user skill, and it will take years for the mass market to catch up. UI-first products have a longer tail than the frontier suggests.

The agent-native buyer is a tough customer. That buyer skews prosumer: small, price-sensitive, and convinced they could build it themselves. One commenter put it flatly: “Prosumers have never been a viable customer segment for the overwhelmingly vast majority of SaaS… whatever you can do, they’ll think they can do it themselves.” The only viable version of this buyer is the enterprise, where you win the whole company behind the technical champion.

There is not yet enough usage to show whether agentic actions are aimed at the right tasks. Repeated requests for hard numbers went unanswered. One builder shipped an AI feature and found that none of their customers wanted it. Sentiment among early users is not the same thing as adoption.

Prompting for the same repeated action is slow. “If I want to check Stripe, I’ll open the app. I’m not going to type out a novel just to see some headline figures. Buttons on screens that summarize and extract key data are still more efficient than prompting.” Fair. A button beats a paragraph for a simple lookup.

Where the two sides converge

Here is what surprised me most. As the arguing waned, both camps landed in roughly the same place: the UI survives, but its job changes.

The interface splits in two. The reading half (overviews, monitoring, audit trails) stays visual and fast, because humans reason better from a rendered state view than from a conversation. The acting half (changes, bulk operations, cross-tool workflows) moves to agents, because agents handle verification, edge cases, and composition across products. Find the note, send the email, update the CRM, one instruction.

Your UI stops being where work happens and becomes where you check what the agent just did.

That reframes the trust problem too. The sharpest skepticism I found was not that agentic automation is inevitable. It was that uncontrolled agents will not be allowed to happen: “I don’t think most businesses or individuals are ready to let agents continuously invoke multiple services without knowing exactly what they’re consuming and what it’s costing them.” Audit logs, scoped permissions, budgets, and cost attribution are not compliance chores anymore. They are the product.

One more thing the camps agreed on, quietly: the walled-garden assistant is a dead end. “Everyone building their own ChatGPT wrapper as a proprietary agent will soon find themselves out of the race. Integration is the key… Nobody wants yet another isolated AI.”

What I would do about it

If you run a SaaS company, this suggests a staged posture, not a pivot.

1. Expose capabilities over protocol-agnostic interfaces: Ship a standard API and an MCP server for every core workflow. Keep the protocol layer decoupled so you can pivot effortlessly as agent standards shift.
2. Reposition the UI as a state-and-audit control room: Strip heavy data entry out of the primary interface. Redesign UI surfaces around instant status overviews, audit logging, and single-click rollbacks.
3. Incorporate strict guardrails for agent invocation: Eliminate risk for enterprise buyers by embedding granular API keys, hard budget caps, and real-time cost attribution.
4. Deprioritize proprietary in-app chatbots: Treat standalone sidebar assistants as a bridge for legacy users rather than a primary product pillar.
5. Pivot outbound sales to real-time intent signals: Replace spray-and-pray email blasts with automated triggers that catch active operational friction—like active hiring or stack migrations—and deliver targeted human outreach.
6. Implement instrument telemetry to track execution channels: Continuously measure the ratio of API and agent traffic against traditional UI interactions. Let real usage telemetry guide product investments rather than market hype.

Where do we go from here?

I want to resist the tidy version of this story, the one where dashboards die and agents eat everything. The skills curve is real. The segment economics are real. The missing adoption data is real.

My recommendation is to build agent-accessible layers now because it is inexpensive, and it is hard to regret. Then you let the usage data decide how far the UI recedes, instead of betting the company on either camp winning the argument.