The Revenue Is Upstream Because the Work Is Not

A market can talk endlessly about applications while paying the companies underneath them. That is what happens when the scarce thing is still raw capability. Buyers pay for access to intelligence, developers pay for tokens, and a long chain of experiments sits between that expense and a business outcome anyone can defend.

The concentration is real, but it is not proof that every other layer is irrelevant. It is evidence that most of the other layers have not become durable operating systems yet. A chat window, a thin workflow, or a promising demonstration can consume a model. It does not automatically create a machine that repeatedly produces valuable work.

Our position is that revenue will keep pooling upstream while companies treat models as the product and implementation as an afterthought. The model providers sell a metered productive asset. Everyone downstream has to prove they can turn that meter into something more valuable than the bill.

Buying model access gives you possibility. It does not give you a specification, authority boundaries, product context, independent proof, safe release machinery, or production feedback. Those are not accessories around the intelligence. They are the system that makes intelligence economically useful.

Without that system, usage expands faster than value. More people open more sessions, generate more drafts, and attempt more changes. The provider records revenue each time the meter turns. The buyer receives a pile of plausible output that still needs selection, checking, integration, and ownership. Activity rises cleanly. Outcomes do not.

This is why a successful pilot can make the economics worse. The demonstration creates demand across the organization before the controls exist to distinguish valuable work from merely available work. The company scales consumption first and discovers later that human coordination is still carrying every handoff the model did not solve.

A software factory closes the distance between model capability and an operating result. It turns intent into a buildable destination, routes the work to agents with bounded authority, preserves context across runs, tests the result outside the builder's preferred conditions, and watches what happens after release. Each stage consumes the last one's evidence instead of starting another conversation from scratch.

That machinery changes the unit you buy. You stop buying isolated answers and start operating a productive asset. A failure becomes a stronger test, a narrower permission, a better specification, or a new routing rule that every later run inherits. The same model call now compounds inside a system instead of evaporating when the session ends.

The model matters. It is simply not the moat most buyers imagine. Models improve, prices move, and leaders change. The durable advantage belongs to the organization that can swap the engine without rebuilding the road, the gates, the evidence trail, and the feedback loop around it.

A thin wrapper cannot claim the difference between an input cost and a business outcome forever. If its only mechanism is a prompt attached to somebody else's model, competition compresses it from both sides. The provider can absorb the feature. Another team can reproduce it. The customer can decide the convenience is not worth another vendor and call the model directly.

A factory earns its place differently. It carries the customer's standards, permissions, systems, release rules, and accumulated evidence. It can be judged on whether work reached production safely and whether the result survived contact with reality. That is harder to copy because it is not a screen around a commodity. It is an operating system shaped by consequences.

This is also where many software jobs disappear. Manual ticket movement, routine implementation, repetitive checking, and release coordination become stages in the machine. Human judgment moves to choosing the destination, setting the standard, and accepting the consequences. Companies that preserve the old coordination layer will pay twice: once for model capacity and again for people performing work the factory should retain.

Revenue concentration tells you where the market is paying today. It does not settle where defensible value will live. To find that, follow what remains after each unit of work finishes. If only the provider keeps the benefit, the buyer rented intelligence. If the buyer's system keeps better context, stronger controls, reusable evidence, and a faster path through the next run, the buyer is building an asset of its own.

Our prediction is that the next separation will not be between companies using different leading models. It will be between companies metering impressive experiments and companies operating factories. The first group will keep sending revenue upstream while debating return. The second will make model capacity one replaceable input in a system they control.

Do not answer concentrated provider revenue by hunting for a cheaper chat box. Answer it by building the layer that turns spend into retained capability. The model vendors already know what they sell. The unresolved question is whether you have built the machinery to keep what you bought.