Introduction Link to heading
High-intelligence applications make dumb businesses. Dumb applications make good businesses.
To be a smart startup, you must be dumb.
The Windsurf warning Link to heading
The intuition largely follows Jevons Paradox. Consider AI code editors like Windsurf. When only Claude 3.7 was available, coding agents were ok but not great. Developers on Windsurf didn’t demand that many agent tokens because the value wasn’t that high. This plausibly allowed Windsurf to charge $20 per month with the monthly charge covering their End-Users’ model usage with Windsurf paying retail.
But when Claude 4 came out each token was marginally more valuable in solving problems, encouraging users to demand more tokens. Producing code with AI started to allow engineers to produce >25k lines of code per week and burn 10 figures in tokens daily. Raising price per seat can give the application layer more buffer but it’s not enough to compensate as consumption increases. This is likely why the Windsurf leadership abruptly left for Google.
Code editors are the first to experience this because the demand for generated code is so high. These physics will find their way to other smart applications like Harvey or Lovable that principally sell cognition. As lawyers go from case lookup to full brief generation, the value shifts from Harvey’s interface to the underlying model’s reasoning. For many long briefs, why not go direct?
The smart app layer is getting squeezed. Windsurf is a preview of what’s coming for every frontier intelligence reselling business.
The paradox Link to heading
The more (frontier) tokens an application must burn to deliver value the worse its gross margins become as it can’t capture the full dollar value those tokens create. Dumb applications do not sell cognition: they sell services whose revenue is orthogonal to tokens burned.
This ‘smart app dumb business’ idea challenges the typical way Silicon Valley B2B SaaS businesses have been built:
Smarter applications are better than dumber ones! Right?!
Indeed, application-layer software executives are excitedly marketing the importance of the application layer in the age of intelligent AI agents. Some even say winners of the application layer have crystalized and that the app layer will go “from selling seats, to selling units of cognition.”
This narrative sounds good but is a strategic mistake.
Today’s growing ARR numbers likely hide broken economic logic that will come to light as the model layer moves up the stack. Is the application layer really just Claude ? Why else would Cursor need to raise so much money?
I posed this idea Dumb Money two weeks ago in the launch of this blog.
Since, friends challenged that we’ve previously seen businesses that started with upside-down unit economics (Uber!) that eventually turned it around. I believe This Time Is Different and I’ll spell out a simple microeconomic model that shows why.
The players Link to heading
There are three economic actors
- Labs: (Anthropic, OpenAI, Google, Meta, etc.,) that produce intelligence
- Apps: (Cursor, Windsurf, Box, etc.,) that package and resell it
- End-Users: business applications who use intelligence to make money
We’ll track the flow of value through the system using the notation:
| Symbol | Definition | Properties |
|---|---|---|
| $I$ | amount of intelligence: tokens produced | |
| $K$ | model capability index | improves over time |
| $\sigma(K)$ | effective intelligence units per token: some models are smarter than others | $\sigma^\prime(K) > 0$ (increasing in $K$) $\sigma^{\prime\prime}(K) < 0$ (diminishing returns) |
| $p$ | lab price per token | |
| $J$ | effective intelligence $:= \sigma(K) \cdot I$ | models get better over $K$ |
| $\Pi(J)$ | end-user’s profit from $J$ units | $\Pi^\prime(J) > 0$ (intelligence increases profit) $\Pi^{\prime\prime}(J) < 0$ (diminishing returns) Usually unobserved by the app layer |
| $R(J)$ | app’s revenue from delivering $J$ intelligence units | $R^\prime(J)$ marginal revenue $R(J) \leq \Pi(J)$ app can’t bill above end-user’s profit |
| $V(J)$ | app’s value add | empirically $V^\prime(J) \le 0$ |
| $\tau$ | end-user’s fixed cost to integrate lab APIs directly |
I’ll use this notation to introduce the application-layer and end-user objective functions and show how their respective optimizations squeeze the app from above and below.
The floor: What apps must pay for intelligence Link to heading
The app
- buys $I$ raw tokens at price $p$ per token
- transforms them into effective intelligence $J = \sigma(K) \cdot I$ to sell to end-users
- so that cost per effective intelligence is $p/\sigma(K)$
Take $\sigma(K)$ to be a dimensionless intelligence multiplier turning raw tokens into effective intelligence units $J$. We can think of $J$ as “quality-adjusted tokens” e.g.,
- 1000 tokens from GPT-3 might deliver 1000 units of intelligence
- 1000 tokens from GPT-4 might deliver 5000 units of intelligence (for $\sigma(K) = 5$)
I do this because the end-user doesn’t care about raw tokens: they want problems solved. $J$ captures “output that matters” irrespective of how many raw tokens it took.
The app’s revenue from delivering $J$ units of intelligence is $R(J)$. It has no functional form, just
- $R^\prime(J) > 0$ (more intelligence generates more revenue)
- $R^{\prime\prime}(J) < 0$ (diminishing returns)
- $R(J) \le \Pi(J)$ (can’t charge more than value created for the customer $\Pi(J)$)
The app chooses intelligence level $J$ to maximize $$ \begin{align*} \pi_{\text{app}}(J) & = R(J) - p\cdot I \\ & = R(J) - \frac{p}{\sigma(K)}\cdot J \\ \end{align*} $$ In practice, the choice of optimal $J$ concerns
- Feature sophistication (basic Q&A v. complex reasoning)
- Token budget per user
- Service guarantees (“good enough” v. “always works”)
But the app’s pricing is constrained by their customer’s ability to buy intelligence straight from the source.
The ceiling: What apps can charge for intelligence Link to heading
To understand this constraint, we need to understand what drives end-user demand.
The end-user has some profit function $\Pi(J)$ that represents the business value they get from consuming $J$ units of intelligence:
- For a software company: faster feature development, fewer bugs
- For a law firm: more contracts reviewed, better research, fewer associate hours
- For customer support: more tickets resolved, happier customers, lower cost
This function has natural properties:
- $\Pi^\prime(J) > 0$: more intelligence creates more value
- $\Pi^{\prime\prime}(J)$: but with diminishing returns
Clearly the end-user cannot pay the app layer more than $\Pi^\prime$ for a marginal unit of intelligence.
The squeeze: when customers go direct Link to heading
The end-user’s ability to go direct creates a binding constraint that determines the app’s survival.
Going direct: the fatal option Link to heading
End-users face two options for consuming intelligence
Option 1: Through the app
- Pay app price per unit effective intelligence $p_\text{app}$
- Receive app value-add $V(J)$ like UI, support, integrations, trust
- Get profit $\Pi(J) + V(J) - p_\text{app} \cdot J$
Option 2: Direct from lab
- Pay lab price per effective intelligence $p/\sigma(K)$
- Incur one-time integration cost $\tau$
- Get profit $\Pi(J) - p/\sigma(K) \cdot J - \tau$
Of course, apps need customers to see $$ \begin{align*} \text{Value from app } & \ge \text{ Value from going direct} \\[0.5em] \Pi(J_\text{app}) + V(J_\text{app}) - p_\text{app} \cdot J_\text{app} & \ge \Pi(J_\text{direct}) - \frac{p}{\sigma(K)} \cdot J_\text{direct} - \tau \end{align*} $$ Rearranging, we get the most the app could charge $p_\text{app}$ before risking its customer goes direct $$p_\text{app} \le \frac{p}{\sigma(K)} + \frac{V(J)+ \tau}{J} $$ As $J \to \infty$, clearly $\tau/J \to 0$ and by L’Hôpital’s rule $$ \lim_{J\to\infty} \frac{V(J)}{J} = \lim_{J\to\infty}V^\prime(J) $$ so that for very large $J$
$$p_\text{app} \le \frac{p}{\sigma(K)} + V^\prime(J) $$Putting it together: The Squeeze Link to heading
The app-layer gets squeezed from above and below.
- Above: The risk of power end-user disintermediating the app means its margins are bound by $V^\prime(J)$.
- Below: The price apps pay $p/\sigma(K)$ for intelligence. To my knowledge labs do not offer special wholesale pricing and I assume no negative margins.
That is, $$ \begin{align*} \frac{p}{\sigma(K)} & \le p_\text{app} \le \frac{p}{\sigma(K)} + V^\prime(J) \\ 0 & \le p_\text{app} - \frac{p}{\sigma(K)} \le V^\prime(J) \\[2em] 0 & \le \text{ app margin } \le V^\prime(J) \tag{1}\\ \text{Total profit} & = \text{margin} \times J \le V^\prime(J) \times J \end{align*} $$
The marginal value of the wrapper varies over levels of $J$
- First 1K units: The UI really helps!!
- At 100K units: UI is nice but not essential
- At 10M units: just pipe me the tokens!! (Claude code)
In the $J\to\infty$ case app marginal value $V^\prime(J)$ isn’t all that high.
The other way to see this is that app value doesn’t really scale at the intelligence consumption level, but rather the individual applications of intelligence, which is a process owned and executed iteratively by the end-user not the app. That is, the process of buying applications runs on human time, not AI time.
The pace of new efficient model releases (Kimi K2! Qwen3, Deepseek R2! GPT5!) accelerates the demand for intelligence. All the indicators would seem to suggest now is the time for apps to rise
- Models are getting better!
- Model prices are falling!
- Demand is exploding! (Jevons!)
- End-user value $\Pi(J)$ is going to the moon!
But for
- sublinear $V^\prime(J)$ (i.e., $V^\prime(J) \to 0$ faster than $J\to\infty$)
- and large end-user intelligence consumption
smart app layer total profits $\to 0$. The very success of AI (better models, lower prices, exploding demand) guarantees the failure of AI apps.
Where’s the smart (dumb?) money? Link to heading
The going narrative is that selling cognition is a trillion dollar opportunity in enterprise.
I showed that when intelligence consumption explodes, the application-layer opportunities for profit vanish.
So what is a durable strategy for scaled intelligent B2B applications? Dumb money!!
Decouple revenue from metered intelligence consumption entirely: Do not sell cognition. Or if you do, sell something orthogonal to cognition consumption like trust, exclusive data, or seats; or choose an app type with very high $\tau$.
- Workflow tools (Notion, Linear, Slack): Charge for the collaborative workspace
- High entropy context flows (Bloomberg, robotics): Charge for proprietary or situated data that AI makes valuable.
- Networks (Discord): Charge for premium community features.
- Trust (AI Underwriting Company): Sell liability protection.
- High $\tau$ (Abridge): Apps with high costs to replace.
Windsurf’s exit is the canary. As models get better, cheaper, and more in demand, the smartest AI businesses will be the ones that look the dumbest on the surface.