Vertical AI is eating SaaS. The survivors will not be apps.

A scheduling tool used to be a business. You picked the slots, it sent the link, you paid per seat per month, and a real company grew on exactly that. Today an agent reads the thread, sees both calendars, proposes the time, and sends the invite, and the scheduling tool is a sentence inside a larger job nobody opened an app to do. The feature didn’t get cheaper. It got absorbed.

That absorption is happening to a thousand point-tools at once, one workflow at a time. And it raises the only question that matters for whoever’s building in this wave: when every narrow job gets its own agent, who actually wins?

Not the best agent. Here’s the line the whole post orbits: when agents replace point-tools one workflow at a time, the winner is not the best vertical agent, it is whoever owns the substrate every vertical agent shares.

The bet everyone is making

The obvious move, the one most of the field is making, is to pick a vertical and build the best agent for it. The best SDR agent. The best support agent. The best agent for invoices, for recruiting screens, for closing the books. Pick a painful, expensive, repetitive job; build software that does the whole job instead of helping a human do it; charge for the outcome instead of the seat.

It’s a good move. It’s also the move with the shortest moat in software history.

Here’s why it fails as a durable position, staged the way it actually plays out. You ship the best SDR agent in your category. For a quarter, you’re ahead. Then the model underneath you gets better, and you didn’t make the model, so that lift arrives for your competitor on the same Tuesday it arrives for you. The prompt scaffolding that felt proprietary turns out to be a weekend for a sharp team to match. The workflow you encoded is, by definition, the workflow everyone in that vertical already knows; it’s the standard, which is exactly why it’s reproducible. Within a few cycles there are four agents that book meetings about as well as yours, and the only axis left to compete on is price.

This is not pessimism about vertical agents. They will eat enormous amounts of SaaS, the shift from selling software seats to selling finished work is real, and investors have been clear that value is migrating toward the layer that coordinates the work rather than the one that merely records it (Bessemer Venture Partners, The State of AI 2025). The agents win the workflows. What they don’t win is each other. A category of near-identical agents racing each other to zero margin is a great outcome for customers and a poor one for any single builder. The agent is the thing that gets commoditized. The question is what doesn’t.

What the vertical agents quietly share

Strip a vertical agent down to what it actually needs to do its one job, and most of it isn’t vertical at all.

An SDR agent needs to know who you’ve already talked to, what was promised, which deals are live, that’s memory. It needs to reach your inbox, your CRM, your calendar, that’s integrations. It needs to act on its own clock so the follow-up goes out Tuesday whether or not anyone logs in, that’s scheduling. And it needs a boundary that says what it may send on its own versus what it must hold for a human, that’s trust.

Now look at the support agent. Different vertical, same four needs: the history of this customer, a reach into the helpdesk and the docs, a clock that escalates the ticket aging past its SLA, and a leash that lets it answer the easy ones and route the hard ones. The finance agent: same four. The recruiting agent: same four.

The naive read is that these are implementation details, plumbing each agent ships for itself. That’s the trap. When every agent builds its own memory, its own connectors, its own scheduler, its own permission model, you get four mediocre copies of four hard problems, none of which improve from the others’ work. The SDR agent’s memory doesn’t know what the finance agent learned about the same account. The support agent re-authorizes the inbox the SDR agent already connected. Four agents, four blindfolds, and the company they all serve is still the only thing that knows the whole truth, by being a person who remembers.

The mechanism, the lesson: the vertical is what differs between agents; the substrate is what they all need, and the substrate is where the value pools. When agents replace point-tools one workflow at a time, the winner is whoever owns the substrate every vertical agent shares.

Why the shared layer compounds and the agent doesn’t

Two things in a system behave very differently over time, and confusing them is the whole mistake. One commoditizes. The other compounds.

A vertical agent commoditizes because its quality tracks the model and the well-known workflow, both of which your competitors also get. There’s no flywheel, last quarter’s best SDR agent has no structural advantage in this quarter’s race.

The shared substrate is the opposite kind of asset, because it gets more valuable the more it’s used, and that value can’t be copied by shipping a better prompt.

Take memory. A company brain that has watched every agent act for a year knows which proposal language actually closed, which customer the calendar invite belongs to, which renewal is quietly at risk. A competitor can copy your agent’s prompt in an afternoon. They cannot copy a year of your company’s accumulated context, because it isn’t code, it’s the lived history of one specific business. The longer it runs, the more it knows, the harder it is to leave. That’s a moat that grows while you sleep.

Take integrations. The first time anything connects your inbox, your CRM, your calendar, your billing, your docs, under one permission model, owned once, every agent built on top inherits that reach for free. The second agent is cheaper to add than the first. The tenth is nearly free. A standalone vertical agent re-pays that integration cost every single time, alone. The substrate pays it once and lends it out.

Take scheduling and trust, together. The clock that lets one agent act unprompted is the same clock for all of them, build it once, every agent gets initiative. And trust, the boundary that decides what an agent may do alone, is earned per company, not per agent: once a business has watched the substrate handle a thousand small actions correctly, that earned autonomy extends to the next agent it hosts, the way a manager who trusts a team extends trust to its newest member faster than to a stranger. None of that transfers when you swap one vertical agent for another vendor’s. All of it stays when the agents are swappable tenants on a substrate you own.

So picture the arithmetic with round, illustrative numbers. Say a company runs five agents today and twenty next year. Build each as an island and you’ve paid the memory-and-integration-and-trust tax twenty times, twenty times badly. Build them on one substrate and you paid it once, and agent twenty-one is a configuration, not a project. The agents are interchangeable. The ground they stand on is not, and the ground is the business.

The turn: you are choosing a landlord, not an app

Here’s what this actually means for the person deciding what to adopt, because it’s a quieter decision than it looks.

When you bring in a vertical agent, you are not really buying the agent. The agent is the part that will be matched, undercut, and replaced, possibly by you, next year, when a better one ships. What you’re actually choosing is where your company’s memory will live, who holds the keys to your connected tools, and whose judgment about what’s safe to do unsupervised will accrete, day after day, into the thing that runs your operation. You are choosing a landlord for your company’s context, and you’ll feel that choice long after you’ve forgotten which SDR agent you started with.

That reframes the build question, too. Building the best agent for one vertical is a race you can win for a quarter and must re-win forever. Building the substrate that every vertical agent, yours and others’, needs to stand on is a position that gets stronger every day it runs. One is a sprint repeated until you lose it. The other compounds. When agents replace point-tools one workflow at a time, the winner is not the best vertical agent. It is whoever owns the substrate every vertical agent shares.

The agents are going to eat SaaS. That part is settled. The open question, the only one worth building around, is whether, when the dust clears, your company’s memory, your integrations, and your hard-won trust belong to you on a layer that’s yours, or are scattered across a dozen apps that are each one model release away from being replaced.

---

That layer is what we’re building at Apollo Space, the substrate the agents stand on, so the vertical you choose is a tenant and the company underneath stays yours.