Sell the Work,
Not the Tool.

Sequoia partner Julien Bek published a tight piece this March that reframes the entire AI business model debate in a single provocation: “The next $1T company will be a software company masquerading as a services firm.” The argument is not about model capability. It is about which side of the market you are selling into, and why the larger budget is always on the services side.

His structure is clean. There are copilots, which sell a tool to a professional and let them decide what to do with it. And there are autopilots, which sell a completed outcome directly to the company that needs it. Harvey sells to law firms. Crosby sells to the company that needs the NDA drafted. The distinction sounds like a go-to-market choice. It is a structural claim about market size: the work budget in any profession is six times larger than the tool budget, and autopilots capture the work budget from day one.

The second part of Bek’s argument is the intelligence spectrum. Not all professional services work is equally ready for automation. Categories with a high intelligence-to-judgement ratio (where the rules are complex but they are still rules) are ripe now. Categories dominated by judgement built on years of tacit experience are next, as AI accumulates proprietary domain data and the frontier shifts. The thesis is not that everything becomes an autopilot immediately. It is that every category will, and the starting position matters because it determines where compound learning begins.

What Bek is describing demands something he does not name: a layer that makes autopilot outputs trustworthy. You cannot sell “we closed the books” if you cannot prove what “closed” means in a client’s specific jurisdiction, ERP configuration, and chart of accounts. You cannot sell “we settled the claim” if the policy interpretation is implicit and unauditable. Autopilots selling outcomes at enterprise scale require governed, versioned definitions of what those outcomes mean.

Bek’s central observation is that copilots are competing with the model. If Harvey makes lawyers more productive, the question every law firm will eventually ask is: productive enough to justify the subscription, or should we just hire fewer lawyers and use the model directly? That question gets sharper with every model generation. Copilots have value but their value ceiling is capped by what the model can do for free.

Autopilots have the opposite dynamic. Every improvement in the model makes the autopilot’s service faster, cheaper, and more accurate, all of which improve the economics of the outcome they are selling. The model improvement is a tailwind, not a competitive threat. And because the autopilot captures the work budget rather than the tool budget, the addressable market is different in kind. A company might pay $10,000 a year for QuickBooks and $120,000 for the accountant to use it. The autopilot replaces the $120,000 line, not the $10,000 one.

That distinction changes the cost of customer acquisition, the sales cycle, the competitive moat, and the compounding dynamic of the business. It also changes the trust requirement. When a professional uses a copilot and makes a mistake, the professional is liable. When an autopilot delivers a completed output, the autopilot owns the result. That shifts quality assurance from a feature to a core capability, which is what makes the governance layer non-optional rather than nice-to-have.

Bek’s most operationally useful contribution is the intelligence-to-judgement spectrum. Software engineering got to autonomous AI first, he argues, because most of the work is intelligence: translating a spec into code, testing, debugging, rules-complex but still rules. The judgement (what to build next, whether to take on tech debt, when to ship) is the smaller slice, and it stays human. AI crossed the intelligence threshold for software engineering first. It is crossing it for other categories now.

The categories Bek identifies as ready share three characteristics. First, the work is already outsourced, which means a budget line exists, the buyer has accepted that outcomes can come from outside, and the substitution is a vendor swap rather than a reorg. Second, the intelligence ratio is high: the rules are complex but deterministic, and the value comes from processing them accurately at speed. Third, there is a structural supply shortage that is forcing buyers to accept AI alternatives before they might otherwise be inclined to.

Healthcare revenue cycle management is the cleanest example. Medical coding translates clinical notes into approximately 70,000 standardised ICD-10 codes. The rules are genuinely complex (a specialist spends years mastering them) but they are rules. The outsourcing is already mature and outcome-based. An autopilot does the same thing at lower cost with no backlog. The buyer already knows what “done” looks like, already has a budget line for it, and is facing a workforce that is not being replenished.

The practical implication: enterprise AI buyers evaluating autopilot vendors should look first at the intelligence ratio of the specific task, not the general category. “Healthcare” sounds judgement-heavy; medical billing is almost pure intelligence. “Legal” sounds judgement-heavy; NDA drafting against a client’s standard template library is primarily intelligence. The category label obscures the ratio. The ratio determines readiness.

Bek’s sharpest strategic observation is about compounding. Copilots accumulate product and customer knowledge. Autopilots accumulate something more useful: proprietary domain data about what good judgement looks like in their specific vertical. An autopilot that has processed 100,000 NDAs knows something about contract risk patterns that no model trained on public data knows. An autopilot that has coded 5 million medical charts knows something about clinical note variability that no standard coding software knows. That accumulated knowledge is the moat.

The strategic implication is that the starting position determines how deep the moat gets. A company that enters medical billing with an autopilot in 2025 has a two-year compounding advantage over a company that enters in 2027, not in model capability (which is roughly shared), but in proprietary edge-case knowledge built from actual production data. The moat is the accumulated domain knowledge that the model has not seen, not the model itself.

This is where Bek’s argument connects directly to knowledge sovereignty. The proprietary domain data the autopilot accumulates has to live somewhere the company owns and controls. If it migrates into model weights, it becomes a training signal for the model provider’s general capability, shared with every other customer. If it lives in a governed semantic layer outside the model, it is a company asset that persists through model changes, compounds with each use, and remains defensible even when the underlying model improves or changes.

For the buyer, this is the question that outlasts any vendor pitch. The autopilot you sign today will get better as models improve. What determines whether that improvement compounds for you, or for the model provider, is where the domain knowledge lives. If your edge cases, your carrier appetites, your jurisdiction rules accumulate inside a layer you own, they stay your asset through every model change and every vendor change. If they accumulate inside the model, you are renting your own operating knowledge back from whoever trained it. Ask the vendor which one it is.

Selling the work means owning the output, and owning the output means being able to defend it. Before you sign, put every outcome-based AI vendor against the same five questions.

• Can it show which definition produced the number? "We closed the books" is only sellable if the vendor can name the revenue recognition standard, the chart-of-accounts mapping, and the jurisdiction rule it applied.
• Are those definitions versioned and approved? If last quarter's close cannot be reproduced after this quarter's rule change, the outcome is not auditable.
• Where does the accumulated domain knowledge live? Inside a layer you own, or inside the model provider's weights, shared with every other customer.
• What happens when a definition conflicts across systems? Two systems calling the same metric two different things should surface before the outcome ships, not after.
• Does it stay yours when the model changes? The autopilot improves with every model generation. Your edge cases should compound for you, not reset.

A vendor that fails those questions can still be fast. It cannot be trusted to deliver an outcome you would defend to a board or an auditor without a human re-checking it, which is the cost the autopilot was supposed to remove. LazyFox is the semantic governance layer that answers all five: it sits above your data stack without migration, indexes domain knowledge once, and governs how every AI answer is produced, versioned, and audited. A defensible outcome is a sellable one, and a governed layer you own is what makes it defensible.