Most software was built for a world where humans did the work. That world is ending.
Replace Ventures is where the case for that change gets made, and where the companies that prove it get built. Not retrofits. Not chatbots bolted onto legacy stacks. The full replacement, designed from the first commit for agents to be the operator.
Every category of business software has the same shape. A database, a UI, and a workforce of humans typing into the UI to keep the database honest.
CRMs, ATSs, HRISs, ERPs, ticketing systems, dashboards. The software is the form. The work is what humans do around it. For forty years the answer to “how do we get more output” has been “hire more people to do more of the typing.”
Agents change which side of that equation the labor lives on. The database stays. The form goes away. The work becomes a call.
A 200-person people-ops team becomes a four-person team plus an agent that handles onboarding, time off, surveys, and the reconciliation work between five vendors of record. A 50-person sales-ops org becomes a three-person team plus an agent that reads every call, scores every deal, and runs the pipeline.
The work doesn’t disappear. Its shape changes. The companies that get built around that new shape from day one will replace the ones that retrofit it.
Retrofits look like an AI panel inside an existing dashboard. Replacements look like an MCP server where every primitive in the category is addressable, and the dashboard is one consumer of it.
Companies whose first user is an agent. The human UI is a consumer of the same primitives, not the source of truth. Hiring, HR, sales, finance, operations — one category at a time, each in a vertical where the incumbent stack is too closed, too brittle, or too human-shaped to survive the shift.
They’re built from a shared foundation. The same agent runtime, orchestration, eval and memory patterns carry from one build to the next, so the same systems don’t get rebuilt every time. It’s how a small team can back many bets at once without going shallow on any of them.
Not the assistant, not the copilot. The thing that actually runs the workflow end to end while a small team supervises the edges.
We build by category, not by feature. One company per vertical, deep enough to replace the incumbent stack rather than ride on top of it.
The hard parts — orchestration, evals, memory, routing — get solved once and carry from one build to the next. Product surface is what makes each company its own thing.
Each company here is built to operate over the long term, judged by revenue and longevity, not by markups.
We lean toward agents that can do real work without a person watching them, and toward products that hold up beyond a demo. In categories where the leading incumbent already has serious agent-native infrastructure of their own, we’d usually rather find a different fight than try to out-build them on their own ground.
We’re also not trying to assemble a long tail of small bets. Every company we start, we start with the intent to operate it, not to flip it. If an idea wouldn’t reward a long horizon, it usually isn’t the right one for us to start.
The model layer is good enough. The tool layer — MCP, structured function calling, retrieval that doesn’t fall apart under load — is good enough. The orchestration layer was the bottleneck, so we built it ourselves and use it everywhere.
The remaining unknowns are not technical. They are about which categories shift first, and who has the company already standing when they do.
The thesis is the why. The writing is where it gets worked out. The companies are the proof.