The native service company is the real AI business model

An agency that takes on a second client hires a second team. A software company that signs a second customer ships the same code it already wrote. One of those businesses gets harder to run as it grows; the other gets easier. For thirty years that gap was the whole argument for building software instead of selling services.

The AI-native company collapses the gap from the other side. It delivers the service, the actual outcome, not a tool to produce it, and it does so without hiring the second team. That’s a third business, and it doesn’t have a clean name yet, so let’s give it one. Call it the Native Service Company.

The thesis is one sentence, and the rest of this post is the mechanism behind it. Don’t sell a seat and don’t sell hours, sell a result that runs itself, with humans only where judgment earns its keep.

The two old models each give up something

Start with the dumb version of “how do you make money from work,” because both real models are refinements of it, and each one pays a tax the other doesn’t.

The agency sells hours. It’s the most honest model there is: a client has a problem, people solve it, the client pays for the people. It scales perfectly in revenue and terribly in everything else. Every new client is new headcount, new coordination, new ways for the work to drift. The economics tell the story, traditional service businesses run gross margins around 40–60% (DealHub), because the cost of delivery climbs in lockstep with the revenue. Growth costs growth. The agency that wins more work has to become a bigger agency, and a bigger agency is a harder thing to keep good.

So the industry’s answer was: stop selling the work, sell the tool that does the work. That’s SaaS, and it’s a genuinely better machine. Write the software once, sell access a thousand times, and the cost of the thousand-and-first customer is rounding error. SaaS gross margins sit at 70–85% for exactly that reason (DealHub, eqvista), once the product is built, delivery is nearly free.

But SaaS quietly handed the customer a bill nobody puts on the invoice.

It sold a seat, and a seat is a license to operate the tool yourself. The software doesn’t do the work; it makes the work doable by a person who still has to show up, learn it, and run it. You pay monthly for the privilege of doing the job with better equipment. That’s why so much purchased software is never fully used: the company bought the tool and never staffed the operator. The agency sells you the outcome and eats the labor. SaaS sells you the capability and hands you the labor back. Neither one sells you the thing you actually wanted, which was: the result, handled.

The third model sells the result, not the access

Here’s the move. Don’t sell the hours and don’t sell the seat. Sell the outcome, and let an agent operating system do the operating that used to require either a team or a logged-in human.

This is the thesis venture investors started calling “services-as-software”, agents that execute a workflow end to end rather than generate an output you then have to act on (Foundation Capital). The naming matters because it inverts SaaS. Software-as-a-service gave you software, charged like a service. Services-as-software gives you the service, built like software. You buy “the invoices are reconciled,” “the leads are qualified,” “the renewals never lapse”, not a dashboard where you could do those things if you found the time.

The catch everyone hits is the same one: that last mile is brutal. Getting an agent to 80% of a workflow takes about 20% of the effort; getting it to the 99%-plus a paying customer demands can take a hundred times more (Foundation Capital). Which is exactly why the model lives or dies on where you put the humans. Don’t sell a seat and don’t sell hours, sell a result that runs itself, with humans only where judgment earns its keep. The agency put humans everywhere. SaaS put humans nowhere and called the gap “self-serve.” The Native Service Company puts them in precisely one place: the judgment calls a machine shouldn’t make alone, yet.

Why this needs an operating system, not a workflow

The naive way to build a service-as-software company is to automate one workflow really well. Pick the highest-pain task, script it, sell it. It works, briefly, and then it doesn’t, for a reason that’s easy to miss.

A single automated workflow is a tool again. It does the one thing, and the moment the real world spills outside the script, a client replies oddly, a tool changes, an exception appears, it stops and waits for a person. You’ve rebuilt the SaaS problem with extra steps: a capability that still needs an operator standing by for everything it didn’t anticipate. The work that breaks an automation is never the work you scripted. It’s the work in the cracks between scripts.

What actually runs a service is not a workflow. It’s an operating system: something always on, holding the full context of the operation, reaching for whatever tool the moment needs, and deciding what happens next without being asked. A scheduler that knows the renewal lands next month. A memory that remembers which version of the proposal the client said yes to. The connective tissue to every tool the job touches. And a permission layer that knows what it’s allowed to do alone versus what it has to hand up to a human. That’s not a bigger automation. That’s the difference between a script and the thing that decides which script to run.

Sell a result that runs itself, and “runs itself” is doing enormous work in that sentence. It means the operating system is the operator. The human is the exception handler, not the engine.

The leverage is in the niches, not the headcount

This is where the model stops being a margin story and becomes a strategy.

An agency that’s great at one niche grows by going deeper or going wider, and going wider means a whole new team for the new niche. The expertise doesn’t transfer; it’s in people’s heads, and people don’t fork. So agencies specialize and stay small, or generalize and get worse. That’s the ceiling.

When the operation runs on an agent OS, the expertise doesn’t live in heads. It lives in the system, the memory of what worked, the edge cases already seen, the judgment calls already encoded. Operate one niche well and you haven’t just earned that revenue; you’ve taught the OS the shape of “operating a niche.” The second niche reuses most of that. The third reuses most of the second. Each one you take on lowers the cost of the next, because the hard part, the operating system that does the operating, is already built and already learning.

Picture the arithmetic, hypothetically. Say a traditional agency needs roughly one operator per niche to keep the service good, so ten niches means something like ten teams. A Native Service Company aims for the opposite shape: a small team that designs the judgment, sets the guardrails, and handles the exceptions, across ten niches, because the OS carries the operating in all ten. The team doesn’t scale with the niches. The system does. That’s the whole bet: a small group of people operating many niches because the operation itself runs on software that gets better every time it runs.

A seat doesn’t compound. Hours don’t compound. A self-running operation that learns from every job it does, that compounds.

The turn: humans move to where judgment earns its keep

It’s tempting to read all this as “fewer people,” and that’s the boring version of the idea. The interesting version is which people, doing what.

When the operating system carries the operating, the humans don’t disappear, they move up to the only work that was ever worth a human’s full attention. Deciding which niche is worth entering. Setting the standard for what “good” means to the customer. Catching the call the machine shouldn’t make alone: the refund that’s technically wrong but right for the relationship, the exception that signals a strategy shift, the moment the script should be rewritten instead of followed. That’s judgment, and judgment is the one thing in this whole stack that doesn’t get cheaper to fake. It’s the thing you’re actually selling, dressed up as a result.

So the model isn’t “remove the humans.” It’s “stop spending them on operating.” An agency spends its best people running the machine. SaaS spends the customer’s people running it. The Native Service Company spends its people on the judgment, the part that earns its keep, and lets the operating system run everything that doesn’t need them. The result that the customer buys runs itself; the people build and guard the thing that makes it run.

That’s the model worth building, and it’s the one we keep coming back to: don’t sell a seat and don’t sell hours, sell a result that runs itself, with humans only where judgment earns its keep.

---

That’s what we’re building toward at Apollo Space, the operating system underneath a company that sells outcomes instead of access, so a small team can run many niches without becoming a big agency to do it. If you’ve ever watched a business get harder to run with every client it wins, that was never the price of growth. It was the price of selling the wrong thing.