Most software was built for a world where humans did the work. That world is ending.

We are building an environment for the future of building companies. One where agents don't just run the work inside a company, they build the company for us.

Every company here is a step toward that. The infrastructure that lets an agent hire, close the books, or ship a feature is the same infrastructure that lets an agent start the next company. We invest in the pieces, build the ones that don't exist yet, and write down what we learn along the way. Humans stay where they matter most: judgement, taste, and being human to human.

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.

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.