The SaaS maturity curve

Every SaaS product sits somewhere on a ladder, and the rung it occupies decides whether AI is its tailwind or its executioner.

The ladder is not new, even if the top of it is. Geoffrey Moore drew the first two rungs in 2011: a system of record (the database that holds the state of a business) versus a system of engagement (the layer people actually interact with). Jerry Chen at Greylock added the next one in 2016, the system of intelligence, software that turns the accumulated data into predictions. And the 2025 frontier has a name too, the system of action, software that does not just remember or predict but does the work. Stack them up and you get a maturity curve any software product can be placed on, and the whole strategic question becomes: which rung are you on, and are you climbing.

The four rungs, from record to action

Flattened into one ladder, the rungs are these.

A system of record remembers. The customer pays it to hold the state of their business (the jobs, the patients, the policies, the invoices) and does all of the actual work themselves. Salesforce in its classic form is this: the CRM holds the accounts and the contacts, and the salespeople do the selling. A system of workflow routes. The software tells people what to do next, enforces the process, moves the ticket along; people still do the work, the software choreographs it. ServiceNow is the archetype, orchestrating who approves what and in what order. Workstream automation does the work, a chunk at a time. The software detects a condition and drafts or executes part of the job, and a human approves it. GitHub Copilot is the version everyone has met: it writes the code, the developer accepts or rejects it. And closed-loop action owns the outcome. The software detects, decides, acts, and watches the result, adjusting on its own, while the human supervises the exceptions instead of performing the steps. Autonomous bidding in the large ad platforms is one of the most established real examples: it senses, bids, and learns inside the guardrails a marketer sets, and no human touches an individual auction.

Each rung captures more of the customer's work than the one below it. Real products straddle rungs, and the good ones are visibly climbing (Salesforce reaching up into agents, Copilot reaching toward autonomy), but each rung still has a clear center of gravity. That is the entire ladder, and it is worth being honest about how far up most products actually are: not far.

Put simply: Software climbs from remembering the work, to routing it, to doing it, to owning the outcome. Every rung does more of the job than the last.

Progressive crystallization: how work becomes software

This is the part I care about most, because it is the mechanism, not just the taxonomy. You do not jump up the ladder. You crystallize your way up.

Every business process begins as tacit knowledge: how a crew prices a job, how a clinic reschedules around a no-show, how an underwriter reads a strange submission. It lives in people's heads. A system of record captures the first layer of it, the facts, as data. A workflow captures the next layer, the sequence, as structure. Automation captures the judgment, the "when you see X, do Y." And a closed-loop system captures the feedback, the "and it worked, so do more of that."

There is a name for this, and it is not mine: a senior director of product introduced me to progressive crystallization. (A 2026 paper by Arun Malik happens to use the same phrase for a different idea, promoting an AI agent's proven exploration into cheaper deterministic workflows, which is a sharp lens on the top rung in its own right.) The work starts as a liquid (tacit, human, improvised) and each rung freezes a little more of it into a form the software can hold. The old knowledge-management literature called the first move tacit-to-explicit conversion; the ladder just keeps going, from explicit to structured to executable to autonomous.

The rule that falls out of it is blunt: you cannot automate what you have not captured. This is why the data foundation, not the model, is the constraint. A product sitting on years of proprietary, captured workflow data has something to freeze. A product with a thin or generic record has nothing, so it cannot climb no matter how good its models are. This is also where vertical software has a structural head start: its data is deep and specific, so there is more to crystallize and the result is harder for an outsider to copy. But the mechanism is general. Any product that has genuinely captured its customers' work can climb; any product that has only stored their records cannot.

Put simply: Work climbs the ladder by crystallizing: tacit judgment becomes captured data, then structure, then executable rules, then an autonomous loop. You cannot automate what you never captured.

The top rung is a loop

The top of the ladder is not a bigger pile of automation. It is a loop.

Detect a signal (an anomaly, a threshold, an event). Decide what it means and what to do. Act, take the action in the real system. Learn, watch the result and feed it back. Then detect again. When the software closes that loop itself, you have a system of action. When a human has to close it by hand, you have automation with extra steps.

This is where the "agent" language finally earns its keep. The useful question is not "is it an agent" but "how much of the loop does it close without a human, and where does the human stand." The industry has three settings for that, and they map cleanly onto trust: human in the loop (the software proposes, a person approves every action), human on the loop (the software acts, a person watches at the portfolio level and intervenes on exceptions), and human out of the loop (the software acts and a person only audits after the fact). You earn your way from in, to on, to out, one reversible, low-stakes decision at a time. Skipping that ladder is how you get a demo that dazzles and a deployment nobody trusts.

Put simply: The top rung is a closed loop, detect, decide, act, learn. Maturity is how much of it the system closes alone, and the human moves from approving every step to supervising the exceptions.

Why climbing is the whole game

Moving up the ladder is not an engineering vanity project. It is where the money is, and it is a different order of money.

a16z made the arithmetic concrete for vertical software, but the logic generalizes. Take a market with ten thousand potential customers. Sell them software at a thousand dollars a month and you have a $120M market. Sell them a system that does the work, at ten thousand a month, and the same ten thousand customers are a $1.2B market. Same logos, ten times the total market. The reframe they push on founders is to stop asking "what can I charge for software" and start asking "how do I target the labor budget."

That is the value ladder in a single number. A system of record prices like a database: a seat, a subscription, a thin slice of the software budget. A system of action prices like an employee, because it is doing what an employee did. You stop competing for the software line item and start competing for the services and labor budget, which in most markets is an order of magnitude larger. The rung you occupy does not just change your product. It changes which budget you are paid from.

Put simply: The record prices like a seat; the system that does the work prices like the worker it replaces. Same customers, roughly ten times the market.

"AI eats SaaS" is only half the story

One popular headline is that AI eats SaaS, and a16z's version is sharper still: "AI eats vertical SaaS." The show-notes companion to this post has a growth-equity investor pushing back that AI is not killing software at all. They are both right, and the ladder is why.

What gets eaten is the static record. If your software's whole job is to remember, an AI-native competitor that also does the work will absorb your function, because, as Bonfire VC puts it, "your metadata isn't your moat, your ability to act on it is." Systems of action eat systems of record.

What survives, and grows, is the record that climbs. The player that has captured genuine proprietary workflow data is the one best positioned to crystallize it into workflow, then automation, then a closed loop, and to capture the labor budget before an outsider does. Vertical software tends to have the head start here, but the deciding factor is captured depth and switching cost, not the category label. Axon is the tidy example: it started in hardware and records, then shipped software that drafts police reports from body-camera audio, moving up into the work itself. The threat and the opportunity are the same move. The only question is whether you make it or it gets made to you.

Put simply: The record that only stores data gets eaten by the system that acts. The record that climbs the ladder eats the work instead. Same starting point, opposite fates.

Where to start if you build software

Two things follow, and both are practical.

First, know your rung, honestly. Most SaaS is a system of record with a workflow bolted on, and its roadmap is a list of more fields and more reports, which is lateral motion, not upward. The question that reorders a roadmap is not "what else can we track" but "what is the next chunk of the customer's actual work we could do."

Second, climb in the order the ladder implies, because crystallization cannot be skipped. You need the record before the workflow, the workflow before the automation, the captured judgment before the closed loop. A team selling an autonomous agent on top of thin, messy data is selling a loop with nothing to stand on; the unglamorous data foundation is what the top of the ladder rests on. Pour it, crystallize the work one rung at a time, and let the human step from in the loop to on it as the results earn the trust.

The software that wins the next decade is not the one with the best system of record. It is the one that turned its record into action first.

Put simply: Find your rung, then climb one at a time, because crystallization cannot be skipped. The winner is not the best system of record; it is the one that became a system of action first.