Every SaaS company is really two companies stapled together. One knows something true about the world: how money moves, what makes a signature legally binding, how to route a phone call, what a carrier charges to move a pallet. The other builds screens — forms, dashboards, permission systems, approval chains, reminders. One company encodes a domain. The other wraps it in screens and charges for every person who looks at them.

For twenty years the second company collected almost all the rent. That arrangement is now coming apart — and it isn’t a reversal, it’s an unbundling. Agents are dissolving the screens, and value is falling back into the part that knew something true.

The average company rents about 106 pieces of software; large enterprises closer to two hundred. Nobody decided this — it piled up one plausible subscription at a time. And most of those products do the same handful of things — store records, route approvals, notify people, draw charts — wrapped in different vocabulary. That sameness is the tell. It’s why a general-purpose process layer, open source or otherwise, keeps threatening to exist — and why agents can now regenerate most of it on demand.

What SaaS actually was

SaaS was less a kind of product than a kind of deal: software is expensive to build and miserable to run, so let us build it once and rent it to everyone. For the cost structure of 2005–2022 — expensive engineers, hard distribution, the browser as the one universal client — the deal was correct.

But it had a flaw that took twenty years to surface: the part of software companies genuinely share is small. Every company that takes payments needs the same card networks, fraud models, and regulatory relationships — call it twenty percent of a payments product, and the twenty percent worth consolidating. The other eighty percent — how your team reviews a refund, who approves a discount — was never really shareable. You tolerated someone else’s version because your own was unaffordable.

Vendors sold the eighty percent anyway, for two reasons. Seats: rails usage is metered and finite, but workflow expands to fill every desk in the building. And stickiness: once your processes live inside a vendor’s workflow builder, leaving means ripping out how your company operates. The domain was the product; the trap was the business.

Seats were never really pricing software. They were pricing human participation in the process — rent on the interaction, collected at the UI.

The pendulum

Make-versus-buy has swung before, and always on the same variable: the cost of making software. In the eighties and nineties companies wrote their own systems, and it was a graveyard — failed ERP projects, IT backlogs measured in years, code that rotted when its author left. Packaged software won because making was expensive; SaaS won because operating was too. Nobody ever preferred generic software. Custom was what everyone wanted. It was just never what anyone could afford.

Hold onto that sentence, because the price of custom just collapsed.

What inverted

Two things changed at once, and they compound.

First, agents write software — and, more importantly, maintain it. The case against in-house software was never the first version; it was year three: the author gone, the requirements drifted, the system load-bearing and untouchable. Maintenance is what killed the in-house era, and maintenance is exactly the work agents are suited to. When maintenance stops being a tax on headcount, the make-versus-buy math inverts — not just for new software, but for the accumulated stock of rented workflow.

Second, the consumer of software is changing. Agents don’t need UIs. An agent doesn’t admire the redesigned dashboard; it wants the data and the actions, over an API, metered. When the user is a person, the wrapper is the product. When the user is an agent, the wrapper is in the way.

The leading indicators have already turned. Software multiples are off roughly a quarter while gross retention holds — meaning the melt shows up at renewal, not mid-contract — and Gartner now puts $234 billion of enterprise application spend, a fifth of SaaS, at risk from what it calls “agentic arbitrage.” Seat-based pricing is forecast to shrink from here. The full evidence, with sources, is in the appendix.

Klarna was the preview. It announced it was replacing Salesforce and Workday with AI, was wrong in nearly every detail — what it actually did was consolidate vendors, standardize, and build some tools in-house — and right in direction: the workflow layer collapsed, and the compliance-heavy vendors stayed. First swings of a pendulum are clumsy. Clumsiness tells you nothing about direction.

The rails test

So what survives? Ask three questions of any software product. Could a competent agent recreate its data from public information? Do its actions touch the world outside software — banks, courts, carriers, regulators, warehouses? And when it’s wrong, is someone liable in a way you could take to court?

Products that pass are rails — the word finance already uses for the systems money actually moves on, and it generalizes. Rails aren’t really software. They’re contracts with reality that happen to have APIs. Concretely, a rail is a domain model kept true: the entities, states, and transitions of a domain, plus the rules that keep moving underneath it — regulators amend, counterparties renegotiate, jurisdictions diverge — maintained so that everyone transacting through it agrees on what just happened. (There is a product hiding in that sentence: a database that ships with its domain’s rules and keeps itself current. Someone will build it.)

Stripe is not a payments UI; it’s banking relationships, fraud models trained on transactions you will never see, licenses in dozens of jurisdictions, and a promise that when money moves, it is someone’s fault if it doesn’t. Twilio is carrier interconnects wearing a REST interface. E-signature is legal standing, not PDF plumbing. Identity verification is underwritten liability. Logistics APIs are trucks. You could generate the code for any of these in a weekend and you’d have nothing, because the code was never the product.

The rails companies wear wrappers too — Stripe has a dashboard, e-signature vendors sell workflow, telephony providers sell contact centers. The melt doesn’t spare their screens. It spares their rails. The dashboard revenue goes; the metered call to the bank network stays.

The test sorts SaaS into two piles: products with rails underneath, and products that are all station and no track. A great deal of very large, seat-priced SaaS is the second kind — its “domain data” is your own data in its schema, its “domain actions” are calls to someone else’s rails. Its real moat was the pain of leaving, and agents are very good at migrations.

What melts

The shapes are recognizable. Workflow tools whose core is a task table. Vertical SaaS that is a process engine wearing industry vocabulary. Systems of record holding your own data hostage in their schema. Analytics that is a UI over your own warehouse. Integration glue, which exists only because wrappers can’t talk to each other. None of these owns anything. They rent your process back to you, and the lease is up.

What remains is shorter: real rails, and the infrastructure beneath everything — compute, storage, models, networks. Payments, signatures, identity, telephony, cross-border complexity, logistics. The list is short because reality’s hard interfaces are few.

The world after

A world with less SaaS is not a world with less software. It’s a world with more software than ever — most of it yours.

Vendors get fewer and deeper: rails companies selling domain data and domain actions over metered APIs, priced like infrastructure. Above them, the process layer comes home — workflows generated, maintained, and rewritten by agents, shaped to how you actually operate rather than to someone else’s median customer. This is the custom software everyone always wanted, at a price everyone can finally afford.

Owning your process layer creates demand for a new layer underneath it: a managed substrate that absorbs the complexity nobody wants back — hosted state with integrity guarantees, runtimes that carry the operational liability, domain-aware databases that ship with the rules of their domain and keep themselves current. Whoever builds that substrate does for owned software what the cloud did for owned infrastructure.

If this is right, it surfaces first in renewal meetings: fewer seats, shorter terms, usage clauses where seat counts used to be. Not because procurement wakes up — procurement is built to renew — but because a CFO sees a competitor running at half the software spend, or a new executive arrives carrying a mandate. These are the last normal renewal cycles. After them, every seat count becomes a negotiation over how much of the process layer the customer intends to take home.

The objections

1. “We tried owning software. It was a graveyard.” It was — and the graveyard had a specific cause: maintenance economics. That cause is gone. Enterprises were never asked to be good at software anyway; they were asked to be good at describing their own processes, which they already do — expensively — to implementation consultants. “Buying” was always half building. The building half stays. The rent goes.

2. “The scoreboard disagrees — software spend is still growing.” It is: up 15% to $1.44 trillion in 2026. But revenue is a lagging indicator; multiples and retention composition lead, and both have turned. Mainframe revenue peaked years after the PC shipped. The scoreboard measures the old game for a while after the new one starts.

3. “AI helps incumbents too.” It does, and the capable ones will use it. But their pricing, their growth, and a decade of their R&D all lived at the wrapper — going deeper into the domain never showed up in net retention, so the muscle atrophied. A seat-based company deploying agents is a company negotiating its own rent down. The honest move is to become a rails company: shrink to the API, meter the domain, let the wrapper go. Some will manage it. It will feel like amputation, because it is.

4. “Enterprise inertia will save the wrapper.” It will slow the melt, not stop it. And the melt won’t take one path. Some companies consolidate wrappers first. Some sign rail agreements at the corporate level. Some adopt a shared — possibly open-source — process layer as a halfway house. Some go straight to owned. The paths differ; the destination doesn’t.

Inertia buys years. It doesn’t buy decades, and it renews annually.

The question

There’s a single question that does most of the work of this essay, and you can ask it of any software product — one you build, buy, or hold shares in:

What remains when the workflow melts?

If the answer is data nobody else has, actions nobody else can take, liability somebody must hold — or a network of organizations whose shared rules live in the product — you’re looking at rails. They survive, with fewer seats and maybe less revenue, the way ports and power grids survive: because reality still needs an interface.

If the answer is screens — screens someone else’s agent will regenerate this afternoon, shaped better to its owner than yours ever were — then what you were looking at was rent. The SaaS era wasn’t a mistake; renting screens was the right response to the price of software, for exactly as long as that price held. It just stopped holding.

---

Appendix: the evidence

• Public software indices are down about 25% from twelve-month highs while gross retention holds near 90% and net revenue retention stalls — the installed base hasn’t moved yet, but the growth engine has. Bain’s own example of seat compression: a customer buys 450 seats instead of 500 and lets agents do the rest. (Bain, February 2026)
• Gartner puts $234 billion of enterprise application spend — roughly 20% of enterprise SaaS — at risk of “agentic arbitrage” by 2030, because agents “break the link between user growth and revenue growth.” Its analyst calls the shift “the disaggregation of the legacy SaaS market… less an apocalypse and more of a metamorphosis.” (Gartner press release, July 2026)
• Seat-based pricing is forecast to fall from 21% to 15% of enterprise SaaS spend as at least 40% shifts to usage-, agent-, or outcome-based models by 2030. (CIO, on Gartner’s “Great Enterprise Pricing Reset”)
• The average number of SaaS apps per company peaked at 130 in 2022 and fell to 106 by 2024 — the first sustained decline in the category’s history. (BetterCloud)
• SaaS M&A hit a record 2,698 deals in 2025, up 28% year over year — consolidation preceding contraction, vendors buying each other’s installed bases. (Software Equity Group)
• Klarna announced it was replacing Salesforce and Workday with AI; in practice it consolidated onto fewer vendors, standardized, built some tools in-house, and kept its compliance-heavy vendors. (CX Today)
• Total software spend is still growing — about 15% in 2026, to $1.44 trillion — the lagging indicator. (SaaStr, on Gartner’s forecast)