A year ago I wrote that seat-based pricing was on its way out. I still think that's right. But pricing turns out to be the small story. Two weeks ago, Salesforce co-founder Parker Harris asked out loud — at his own company's developer conference — why anyone should ever log into Salesforce again. Not as provocation. As direction. Salesforce announced Headless 360 the same week: the entire platform exposed as APIs, MCP tools, and CLI commands, with Marc Benioff's tagline plain on the box — "No browser required. Our API is the UI." When the co-founder of a $300B SaaS company is openly questioning why his platform has a UI at all, the conversation about agentic software just stopped being theoretical. The bigger story isn't that agents change how SaaS gets paid. It's that they take the UI off the table. And when the UI goes, most SaaS products will discover that the UI was the only durable thing they had.

// the moat

Most SaaS apps are forms and workflows around a database. I wrote that line a year ago and I'd write it again. What I didn't draw out is what happens once you remove the forms. The UI was doing a lot of unglamorous work. Onboarding. Defaults. Permission gates. Cross-sells. The order of buttons that quietly encoded which workflow the company endorsed. The dashboards that told users what mattered. The friction that kept people on the rails. Strip the UI off and what's left? A schema. Some business logic. A few integrations. That's a thinner thing than most founders are willing to admit. Especially in the modern PLG layer — the Notions and Linears and Figmas of the world — where the entire reason customers chose the product was that the UI was great. Those are the most exposed. The deeper enterprise apps — Salesforce, ServiceNow, SAP — never had UI as their moat. The moat was the data graph, the integration sprawl, the customization, the switching cost. Those companies have a different problem, which is what Salesforce is now confronting in public.

// nouns and verbs

Software today sells nouns. A CRM. A helpdesk. An ERP. A project tool. We built whole companies, whole categories, whole conferences around these nouns. Agents don't want a CRM. They want to qualify a lead. They don't want a helpdesk — they want to resolve a ticket. They don't want a document store; they want to find the contract clause and summarize the change. The unit of value moves from the noun to the verb. From the application to the action. But here's where it gets interesting. The noun doesn't disappear. The agent still needs the lead record, the account history, the schema that defines what "qualified" means at this company. The system of record matters more in an agent world, not less, because the agent has no other ground truth. What changes is access. Agents want verb-shaped access to the noun. Look at what Salesforce shipped — sixty-plus MCP tools, thirty-plus preconfigured coding skills, the full platform reachable through Claude Code, Cursor, Codex, Windsurf. The data graph stays. The verbs come out. That's exactly what the frame predicts: the data layer keeps its moat, the workflow-and-screen layer above it loses it.

// the incumbents aren't waiting

The lazy version of this argument is that agents disrupt platform gravity. Cleaner workflows, contestable per call, the big platforms get unbundled. I'd love that to be true. It probably isn't. What's actually happening is that the incumbents see this coming and are racing to be the headless layer. Salesforce has Headless 360 and Agentforce. Microsoft has Copilot agents wired through the whole stack. ServiceNow has Now Assist. They're not getting disrupted. They're trying to preserve their gravity by moving the lock-in down a layer — from the screens to the data graph and the trust layer underneath. Whether that works is the live question. The first analyst commentary on Headless 360 was already pointing out that modern data stacks can replicate much of this with less vendor concentration. And nobody at Salesforce has said yet how any of it gets priced — which is the entire question, because the pricing decision is where you find out whether the platform is selling capability or selling lock-in. This is the part the seats-are-dying argument was incomplete on. Pricing follows architecture. The architecture is going headless. The work is happening at the API boundary, which is exactly where you can meter it — for the first time in SaaS history, the product surface and the billing surface are the same surface. That's not a small thing. The providers who get this right won't be the ones with clever spreadsheets. They'll be the ones whose architecture and economics are actually aligned.

// three humans and a dog

The clearest example I've seen of where this lands isn't theoretical. Jason Lemkin, who runs SaaStr, posted a description of his own company the day Headless 360 was announced. Three humans. One dog. Twenty-plus AI agents in production. Salesforce is the system of record for every deal, every contact, every sponsorship. And almost nobody logs in. The agents do. The humans look at a custom dashboard built on top of Salesforce — fourteen thousand lines of code, real-time, predictive — that tells them what to do every day. The Salesforce UI exists. They just don't open it. That's the picture. Not a Gartner forecast. A working company, today. The system of record is intact. The UI is vestigial. The agents do the work and a small team of humans configures, reviews, and decides. If you want a preview of what mid-market enterprise software looks like in three years, that's it.

// the bifurcation

I want to be careful here, because the loudest version of "headless wins" is the wrong one. No more UIs! Everything is API! That's not what's happening, and people who say it haven't sat in a real enterprise change-management meeting. What's happening is bifurcation. Execution goes headless. Governance stays UI. Humans don't disappear from the loop — they move up the loop. They configure the agents. They review the exceptions. They set the policies. They audit what happened. That's a different surface, a different set of users, a different design language. Smaller, higher-stakes, much more boring than the consumer-grade dashboards we've spent a decade building. Most of the dashboards being built right now are obsolete on arrival, because they're execution surfaces dressed up as governance surfaces. They show users what to click. Governance surfaces show users what already happened, what nearly went wrong, what the agents are about to do. That's a different product. If you're building SaaS today, you should be asking which of your screens are execution and which are governance. Most teams don't have that distinction in their roadmap. They will.

// intent

The UI was carrying intent. Implicitly. Nobody wrote down "this is how we qualify a lead at our company" — they expressed it through which fields were required, which workflow the salesperson clicked through, which approval kicked in at which threshold. The product designed the org's intent into the screen, and the org used the screen, and intent stayed legible without anyone having to articulate it. Headless rips that out. When agents do the work, intent has to be made explicit. In policies. In capability descriptions. In contracts that say what the agent is and isn't allowed to do, in what conditions, with what audit trail. This is work most organizations have never done — because they never had to. The UI did it for them. We call this Intent Engineering, because it deserves a name. It's the discipline of making organizational intent legible and governable for systems that don't have eyes. The bifurcation only works if this work gets done. Governance surfaces that aren't anchored to explicit intent are theater. You can't supervise what you haven't articulated. The supervisor role — which is where most enterprise leverage moves to — is real and important, but it depends entirely on the org being able to say, in writing, what it actually wants. That's the work. Not building the agent. Making the company legible enough that the agent can be governed at all. Most haven't started. The ones that do this first will run circles around the ones still shipping screens. The screens aren't going away. They just stop being where the work happens.