Quick read

  • AI has had its mass-adoption moment. What it doesn't have is the lock-in and low marginal cost that made the App Store an economy.
  • Models are substitutable, model makers compete with their own customers, and every query consumes chips, power and capacity.
  • The durable advantages are more likely to sit in trusted business networks, regulated workflows and scarce physical infrastructure.

In early 2023 Jensen Huang called this “the iPhone moment of AI,” and I understand why the phrase stuck. ChatGPT took something most people had encountered only through research papers or developer tools and made it immediately usable; you could open a chat window and see the change for yourself. As a description of a product breakthrough, the comparison worked.

The problem is what the comparison smuggles in. The iPhone was a product, but it also produced an economy: the App Store gave developers access to customers, helped build businesses such as Uber, Instagram and WhatsApp, and made the phone itself more useful. Call AI an iPhone moment and you imply that the same business structure follows. That needs its own argument.

A widely usable capability and a durable platform economy are separate achievements. The first gives people a new tool; the second gives both the platform and the businesses around it a reason to keep investing. AI has the first. As for the second, two foundations of the App Store model look much weaker here: network effects that keep users and developers in one ecosystem, and the ability to distribute another copy for almost nothing. Follow those two differences through and the right comparison turns out to be cloud computing, which is still an enormous business, but one with a very different distribution of profits.

The iPhone Flywheel

Apple's model worked because four conditions reinforced each other.

  • The platform was profitable from day one. Apple made its money on hardware; the App Store's 30% commission was a bonus, not a survival mechanism.
  • Distributing another copy of an on-device app cost almost nothing, because users supplied the hardware it ran on. (Developers still paid for server-backed services, support and customer acquisition.)
  • Switching was expensive: leaving iOS meant leaving behind apps, purchases, iMessage threads, and years of habit.
  • Most important, the App Store was a real two-sided market: more users drew more developers, more developers produced more apps, and more apps drew more users.

Put those together and you get a flywheel:

The iPhone flywheel converges: every turn returns to the start
Figure 1: The iPhone flywheel. Lock-in closes the loop by turning today's users into tomorrow's hardware sales.

The arrow that matters is the one that returns to hardware sales. Users stay, buy another iPhone, and finance the platform with their next purchase; all of the activity ends up strengthening the same center.

Apple also had a reason to want developers to succeed, because useful apps sold phones. It could and did absorb individual features, as the flashlight apps found out, but developers still had a route to demand. That alignment matters more for this comparison than the famous 30%.

Two Maps

The lazy way to map this onto AI is to replace “iPhone” with “model” and “app” with “agent.” That hides a conflict inside the model maker's business, and it takes two supplier relationships to see it.

Cloud providers → Model makers

Cloud providers supply model makers. The provider earns from usage, can host competing models, and doesn't need to pick a winner; when its customers grow, so does its revenue. This is a clean platform relationship.

Model makers → Agents

Model makers supply agents, and this relationship looks more like WeChat and its mini-programs: the consumer assistant controls the entry point, the conversation history, and increasingly the memory. An independent service can be useful and still be renting access to its own customer.

Discovery changes too. In WeChat, the user chooses a mini-program. In an assistant, a request to book a restaurant may leave the choice of provider to the model, which means a business has to be selected by an intermediary as well as preferred by a customer.

Alibaba offers a concrete test of this shift. My analysis of Qwen AI shopping and Alibaba’s next growth engine examines whether connecting the assistant to commerce can give Alibaba control over where shopping begins.

The model maker wants developers to build products and buy tokens; it also wants consumers to stay in its own interface. Those incentives can coexist, but they don't always favor the same business, and coding is where you can see it: independent tools pay API bills to model makers while competing with those same suppliers' coding agents. Their cost of goods is a competitor's revenue.

(There is a related tension in Circle’s move toward owning the payment last mile: a network supplier gains control over customer economics by moving into a business its partners already run.)

Break One: Models Are Easier to Switch Than Ecosystems

The asymmetry I keep coming back to is this: frontier model development is expensive to enter, while changing the model behind an application can be easier than moving the application itself.

Three different advantages get lumped together under the word “moat,” and each one needs to be tested separately.

  • Direct network effects, where other people's use makes a product better for you, as with messaging or social networks, are almost entirely absent: millions of other people using a chatbot does not make your chatbot better.
  • Two-sided network effects are weak. Shared protocols such as MCP make integrations portable (though not costless: support, authentication, tool behavior and workflow state still differ across providers).
  • A data flywheel from user conversations is not something I would assume. The value of that data depends on permission, quality, and whether it is actually used in training or evaluation; compute, algorithms, and curated or synthetic data matter too.

What AI does have in abundance is economies of scale: only a handful of companies can afford to train frontier models. Scale keeps a provider competitive on cost and capability, but it does nothing to stop customers from leaving. That shouldn't be overstated: a developer can change an API route quickly while a production migration still takes new evaluations, prompt changes and compliance review, and users who try another assistant still face the cost of moving their history, memory and workflows. Even so, Ben Thompson put it succinctly in Apps, Agents, and Aggregation: "Models are relatively substitutable." The stickiness lives in the agent and the context it accumulates, not in the model underneath.

Now redraw the flywheel with AI inputs. The early steps hold up. The return path doesn't.

The AI flywheel diverges: value scatters instead of returning to the start
Figure 2: An analytical scenario. If users and builders can switch suppliers, growth need not reinforce one model maker’s pricing power. Absorption is one possible response, not the only route to retention.

Better models attract users, and demand attracts builders; neither step means both groups stay with one supplier. Switching and multi-provider use send the value somewhere else: to users, in the form of lower prices, and to chips and power, in the form of more spending.

A model maker has one obvious way to bring that value back, which is to absorb a successful use case or launch its own agent: the supplier enters the business its customer was building. That improves the model maker's economics and narrows the independent application layer, and if it becomes the routine way of capturing returns, instead of an occasional copied feature, builders have to price that incentive into their choice of platform.

Apple's loop returns value to a common center. AI's distributes it among users, infrastructure suppliers, and model makers moving into applications. All three flows can grow, and growth by itself tells you nothing about whether a platform economy is forming; the test is where the money returns.

(My comparison of PDD, JD, Alibaba and Amazon follows the same question through retail: greater efficiency does not settle who keeps the gains.)

Break Two: Atoms, Not Bits

The second difference is physical. The App Store analogy makes expansion sound like distribution, but an iPhone customer arrived with a device they had already paid for; an app ran on that device, and another copy cost almost nothing. (Server-backed apps had operating costs, of course, but the user carried much of the execution hardware.) Apple made the phone and collected payment at the register.

Every cloud AI query, by contrast, is work on the provider's infrastructure. Compute, electricity, and cooling have to be available when the request arrives. Lower inference costs help, but growing demand still consumes capacity, and chips, data centers, grid connections, and permits all run on physical timelines.

The next app user costs almost nothing; the next AI user costs compute
Figure 3: On-device apps and cloud inference place serving costs in different places. Apps with server-side services also incur ongoing costs.

That puts three costs back into the picture.

  • Cloud inference consumes resources on every request (how much, and who pays, depends on utilization, caching, model size and whether the work runs on-device).
  • Capacity has to be built ahead of demand, which is why capital spending runs so far ahead of revenue.
  • Bargaining power accrues to whoever controls the scarce physical inputs. That is the profile of cloud computing, not the App Store.

The Inverted Pyramid

Put the two breaks together and you get the current distribution of profits, which is upside down. A mature application economy looks like a large, revenue-generating application layer sitting on a profitable platform. Today’s AI stack has chipmakers capturing large profits, cloud providers earning below them in the chain, and many model makers still losing money; application businesses, meanwhile, pay an inference bill on every use, sometimes to a supplier that is competing for the same customers. I wouldn't assign those businesses traditional software margins.

Doubao makes the application-level question concrete. My analysis of ByteDance’s AI strategy and Doubao monetization asks whether its large audience can generate enough revenue to cover inference costs and support a new business.

The industry has committed hundreds of billions of dollars to data centers, chips, and power, and in the end that has to be paid for by customers using the resulting services. Financing can carry the buildout until those revenues arrive; it can't make them arrive.

The financing is also partly circular: chipmakers invest in labs that buy chips, and cloud providers invest in labs that rent their capacity. That accelerates growth while demand is rising, and amplifies any correction if it stops. Thompson drew the comparison to the railroad boom of the 1870s in Nvidia's Risky Business, and the parallel is apt: the infrastructure was real, the demand was real, and the financing still broke.

The model maker is caught in the middle. It needs applications to justify the infrastructure, because it can't build every vertical product itself; weak differentiation at the model layer, though, gives it every reason to own the valuable applications, which is the absorption branch in Figure 2. A fast-growing market can perfectly well settle into an oligopoly with heavy capital requirements and ordinary returns, and to expect search-like monopoly economics I would want to see durable lock-in or reinforcing network effects. Training scale is neither.

Converging Again: The Closed, Compliant Loop

The open model layer is not the only place to look for network effects, though. In an open market an integration can reach several models, users can keep several assistants, and a useful feature spreads quickly. A closed business network works differently: participants need verified identities, shared permissions, audit trails, and an agreed allocation of liability, and every new qualified counterparty makes the network more useful to everyone already in it. A better model can't copy that membership.

Inside a closed, compliant loop, the flywheel converges again
Figure 4: The closed-loop flywheel. Inside the gate, each vetted member makes joining worth more, and even the model has to pass the gate to get in.

This is a flywheel that returns. Payments, settlement networks, exchanges and OTC desks already organize their activity around licensed or verified counterparties; if agents start transacting for institutions, they inherit those requirements, and the next admitted counterparty expands what existing members can do inside the same network.

I would look for the same pattern in agent-to-agent commerce, shared organizational knowledge, and consortium workflows. The question to ask is who governs identity, permissions, and settlement, and whether one more participant makes that specific network more valuable, which is a much more concrete test than whether a product has an AI feature.

(The manufacturing version of this argument is in my essay on industrial AI and producer profit, where orders, standards and supplier coordination decide who captures the value of a shared technology.)

You can already see the major platforms reaching for this. Microsoft's new Copilot, per The Verge’s report on Copilot’s “super app”, pitches its Autopilot agent as enterprise grade precisely because it comes with its own identity, permissions, audit, and governance inside a customer's tenant. Those controls can become a condition of enterprise adoption; whether they become a barrier depends on switching costs and credible alternatives.

What I find most interesting is what happens to the model inside such a loop: it stops being a commodity input and becomes a condition of membership. The loop can only admit models that meet its standards — auditable, secure, predictable under regulation — which means model makers end up competing on trust, not just on price.

There is already evidence of this. Thompson noted in Frontier Overhangs that enterprise customers pushed back on Anthropic's requirement to retain their data in order to access Fable, and the requirement was gone by Fable 5.1. Customers were choosing models on data handling, not raw capability.

This is the market Dario Amodei has bet Anthropic on. His "race to the top" argues that labs should compete to raise safety standards, and Fortune’s analysis of Anthropic’s safety positioning reports that the safety-first positioning is what has reassured corporate buyers that its models carry less risk. Seen through this essay, that is a bet that a model maker's way out of the diverging flywheel runs through closed, compliant loops, where passing the gate is worth more than being the cheapest.

Compliance, in other words, is a source of defensibility as well as a cost. A better model can absorb a software feature; it cannot inherit licenses, admit approved counterparties, or assume liability for their transactions. Those are assets a builder can build on independently of model quality.

Three Futures

Different parts of the industry may well end up in different places. I see three plausible paths.

1. Cloud-ification

Models become infrastructure. Providers earn from scale and leave enough room for their customers to build durable application businesses, and value accumulates in applications, data and distribution. This is the healthiest path for a long investment cycle, because suppliers benefit when their customers succeed.

2. Vertical integration

Model makers take the largest use cases for themselves: assistants, coding, search and office work. Independent companies concentrate in regulated niches and deeper verticals. The result is a large but concentrated ecosystem with something like the economics of WeChat’s mini-program market: plenty of activity, and a small set of companies capturing much of the value.

3. A capex correction

End-user revenue fails to catch up with infrastructure spending, capital gets harder to obtain, and the system has to absorb the bill. That would not prove the technology was useless. The fiber glut around 2000 destroyed companies and left cheap bandwidth for the businesses that came later; an AI correction could likewise leave capable, inexpensive models for the next group of builders.

No Second Apple

The iPhone combined hardware profit, nearly free app distribution, switching costs, and developer demand that reinforced itself. That combination is very hard to reproduce in cloud AI, and inference adds a physical bill that never goes away. My base case is the cloud era: infrastructure companies at enormous scale, with value also accruing to users, applications, trusted networks, and whoever holds the scarce inputs. What would change my mind is an open AI platform with durable network effects that rewards independent builders.

For a builder, the test is practical: if the next model is ten times smarter and ten times cheaper, does your product get better or become unnecessary? Customer access, a trusted workflow, and a network people rely on become more valuable with better models. A product built around a temporary model weakness has to keep outrunning its own supplier.

That, in the end, was the significance of the iPhone. Apple won, but developers built valuable businesses in its ecosystem, and their returns were the reason they kept building. A rising market capitalization doesn't tell you whether AI has that; the returns earned by the businesses around the platform do.