Subscriptions Were a Workaround

15 Oct, 2026

In 1999, Nick Szabo wrote an essay called "Micropayments and Mental Transaction Costs." The argument is simple. Micropayments kept failing, and it wasn't because the technology was bad. It was because deciding to pay costs something. If I have to stop and ask myself "is this article worth a penny?", the thinking costs me more than the penny does. So I don't want to pay a penny 300 times a month. I'd rather pay $20 once and stop thinking about it.

That's the subscription. It isn't the natural shape of the economy. Most of the economy has always worked on paying for the thing you got: groceries, gas, a haircut. Subscriptions are a workaround for two costs that made small payments impractical online.

The first is the cost of settling the payment. Online card pricing is roughly 2.9% + $0.30. For the fee to be under 10% of what you're paying, the payment has to be at least:

$0.30 ÷ (0.10 − 0.029) ≈ $4.23

A $0.01 article would carry a fee of about 3,000%. So anything under a few dollars had to be bundled.

The second is Szabo's cost: the human decision. Even with free settlement, I'm not going to make a thousand tiny purchasing decisions a day. I don't have the bandwidth.

So we bundled. $20 a month for this, $15,000 a year for that, and hope it pays off.

Both of those costs are collapsing right now, and I think that changes how money gets made on the internet.

Agents make deciding nearly free

Settlement is already cheap. Fees on Ethereum L2s have dropped from around $24 to under a cent. Stablecoins on Solana, sats over Lightning, dollars over Visa: the rail honestly doesn't matter to this argument. What matters is that the second cost, the decision, is going to near zero.

For an agent, "is this worth a penny?" is a few thousand tokens. That's a fraction of a cent. An agent can afford the decision that I can't.

Here's what that decision looks like. Any real goal breaks into subgoals, and for each one an agent can either make it, by spending its own tokens, or buy it, by paying a service.

Make:

cost to make = (new tokens × token price + cached tokens × cache price) ÷ chance of success

Most of what an agent reads is its own context, re-read on every turn. Those reads come from a cache and bill at about a tenth of a new token. Dividing by the chance of success accounts for retries. If the agent only succeeds 60% of the time, it pays for the failures too.

Buy:

cost to buy = price + tokens to find, call, and check the result

Comparing the two gives an exchange rate:

X = price paid ÷ tokens saved

If a service sells tokens cheaper than the agent can generate them, buy. If not, make.

A concrete example: finding someone's work email by handing it to a subagent. My median subagent run reads about 150K new tokens, writes about 2K, and re-reads roughly 5.3M tokens of cached context across 46 turns. With a frontier model at $5 per million input tokens and $25 per million output, and cache reads at a tenth of input, that's about $0.75 + $0.05 + $2.63 ≈ $3.40. At a 60% success rate, the expected cost is about $5.70. A lookup service charging $0.05, plus a couple thousand tokens to call it, is about $0.06. Buying that subgoal wins by roughly 95×.

But summarizing a document the agent already has might cost $0.15 in tokens. A service charging $0.10 barely wins, and as tokens get cheaper, it loses.

The U

So no goal is all make or all buy. Picture one goal with a dozen subgoals, and plot total cost against how much of it you buy.

Buy everything and you're expensive. You're paying for subgoals the agent could have done itself for pennies. That's the bundle: the subscription logic of paying for the whole package whether or not each part was worth it.

Make everything and you're also expensive. The agent burns nearly $6 grinding out an email lookup that someone sells for six cents.

The cheapest point is in the middle: make what's cheaper to make, buy what's cheaper to buy.

total cost = (cost to make the subgoals you keep) + (cost to buy the subgoals you hand off)

Sort the subgoals by how much buying saves. Buy from the top of the list, and stop at the first one that's cheaper to make. The bottom of the U is exactly where the exchange rate crosses the token price.

Here's the important part: only an agent can sit at the bottom of that U. Finding it takes a separate make-or-buy decision for every subgoal, every time. Humans can't afford that many decisions, which is why we pick a corner. Subscriptions are the buy-everything corner. Doing it ourselves is the make-everything corner. Szabo's mental transaction cost is what kept us off the bottom of the curve.

Call the shift a leverage ratio:

R = spending decisions made by agents ÷ spending decisions made by humans

A subscription keeps R at about 1: one human decision, once a month, per vendor. An agent with a budget pushes R into the thousands. My job shrinks to setting the goal and the budget. The agent spends it at a resolution I never could.

There's a lot of waste to recover by getting off the corners. Zylo's 2026 SaaS Management Index found only 54% of enterprise SaaS licenses were actually used in 2025, and the average organization wasted about $19.8M a year on the rest. Median SaaS spend is around $9,455 per employee. Nearly half of that pays for things nobody opened.

This isn't "give an agent money and it's free money." If the goal is wrong, the agent will spend precisely on the wrong thing. But if you know what you want, an agent can spend the same dollar with far more nuance than a human ever had time for.

A data point of one

This isn't hypothetical for me.

I was using Linear's free plan to coordinate my agents. Multiple agents, each spawning subagents, all posting updates and moving tickets. I burned through what was supposed to be a month in about a week. Linear's model assumes a human calls its API a few times a day. My agents made one person look like an organization, so the pricing expected me to pay like one.

So I had the agents use the file system as their shared board instead. That's Domino. It's free, and it works.

Here's the math on why that happened. Seat pricing assumes each seat makes calls at about a human rate. The vendor's margin per seat is:

margin = seat price − (cost per call × human call rate × agents acting through the seat)

With one human, the margin is healthy. As agents per seat go up, it shrinks, and past a certain point it goes negative:

agents per seat > seat price ÷ (cost per call × human call rate)

At that point the vendor has three options: throttle, raise the price, or meter. Only metering survives agents.

With typical SaaS numbers (serving a seat costs about 20% of its price) and each agent hitting the tool a fifth as often as a person, the margin runs out at about 20 agents per seat.

I feel this from the other side too. I pulled my own Claude Code logs for the last month. On a normal day I type 55–70 prompts and spawn 20–30 subagents. Heavy days are 200–300 prompts and 70–100 subagents. When I've run scripted, headless jobs, the busiest days hit about 1,000 sessions.

I'd run 1,000 a day all the time if I could. What stops me isn't attention or ambition. It's that my subscription has a weekly limit, and I don't have the capital for that many tokens on top of it. So I ration. I built a scheduler, Pit, that has agents bid on tasks with a budget, specifically because every token has to count.

That's the seat equation from the customer's side. The vendor hit its limit and throttles me, so I have to be blunt about what I run. Metered pricing wouldn't necessarily be cheaper for me at 1,000 sessions a day. But it would let me decide spend per task instead of rationing everything against one weekly cap.

The same thing, at scale

GitHub is the version every software engineer can feel. Its COO said 2026 commit volume would likely reach about 14 billion, versus 1 billion the year before, and much of that growth is agents. An unofficial tracker rebuilt from GitHub's own status feed has shown 90-day uptime hovering around 90%. That's not a lot of nines. If you've watched Actions go down again and your CI refuse to run, you've felt it. GitHub's infrastructure was built for how humans write code, and agents don't write code like humans.

Then this week, Anthropic published how it moved its monorepo off Git to an in-house system called Scion. Daily merges went from about 2,500 in May to more than 30,000 in September. Seven engineers built it in five months, and it uses about 200× less CPU and memory than the Git mirror setup it replaced.

It's the same decision I made with Linear, a tier up. Anthropic could pay for enterprise GitHub. But making GitHub work at Anthropic's scale would take a lot of GitHub's engineering, and Anthropic was growing faster than that could happen. Agents made making cheap enough that the bottom of the U moved. Domino at my scale, Scion at theirs.

You've already seen this model

If this all sounds speculative, the economy has already moved in this direction. You've been watching it.

The AI labs sell intelligence per unit. Anthropic's revenue run rate passed $65 billion at the end of July, up from about $9 billion at the end of 2025, and roughly 80% of its revenue comes from API access and enterprise contracts billed per token. OpenAI is around $40 billion. That's on the order of $100 billion a year in pay-per-use, for the single most important input an agent has.

My argument is that this model spreads outward from inference to everything agents touch.

What's left to buy?

Here's the honest problem. As models get smarter, making gets cheaper, and the bottom of the U slides toward make. An agent can search the web. It can find fresh information as fast as I can, probably faster, because it knows where to look. If it needs something from Common Crawl, which is more than 10 petabytes of the open web, it can write the code to dig through it. So what stays on the buy side?

I'd assume agents mostly have access to the same information, and bet on three things.

1. Compute as a service. "Pay to run this container." Compute is physical, it's scarce, and it's getting scarcer. DRAM contract prices jumped 90–95% in a single quarter in Q1 2026, the largest increase on record, and TrendForce doesn't expect meaningful new capacity until late 2027 or 2028. People are running inference on PS5s. Subscriptions hide compute scarcity, so when compute gets tight, flat plans throttle. Pay-per-use passes the scarcity straight through, and agents can route around it.

I modeled this against the agent forecast later in this post. Assuming the world serves around 300 trillion tokens a day today and AI power grows from about 2.3 GW to 150 GW by 2030, agents already want more runs than exist. The buildout catches up around 2030, falls behind again once power growth slows, and only pulls ahead for good when agents per person top out.

2. Already computed. Google's index is the classic case. Anyone could crawl the web. But someone already paid to crawl it, store it, and rank it, and they can sell the answer to N buyers for the cost divided by N. Common Crawl's data is free to read, but processing petabytes of it is not. It's cheaper for one party to hold the petabytes and charge a fraction of a cent per query than for every agent to rebuild it. The service isn't selling knowledge the agent couldn't find. It's selling the fact that the work is already done.

Monopolies form here, because fixed costs are huge and shared. They always do. They also tend to get bloated and detached from the problem until someone works around them. Google's index is now being worked around by the same technology this post is about.

3. The unknown as a service. In 1921, the economist Frank Knight split the unknown into two kinds. Risk has measurable odds, like dice or insurance. Uncertainty has no odds, because the thing has never been done. Knight argued that profit is what you earn for bearing uncertainty, because risk gets priced away.

Agents are getting very good at risk. Give one a goal and it'll estimate its chances, check its work, and grind out the answer the way it was trained to. But hand an agent the job of building a search engine in 1997, and I think it builds Yahoo. It categorizes, clusters, builds subgraphs, and solves the problem the in-distribution way. The bet that won was a bare search bar with no categories and everything else handled in the details. Nobody could have priced that bet beforehand. It was a human interpretation of what the internet was.

That's what I think humans keep selling, at least for now: bets too far out of distribution for an agent to price. Interpretations of data that nobody has made yet. Maybe agents get there too. Every prediction about AI so far seems to have come true faster than expected. But today the human sets the frame and makes the bet, and the agent executes it at a resolution no human could.

The market isn't 8 billion people

Every market-size estimate I've ever seen starts from the same ceiling: there are about 8 billion people, so that's the most buyers you can have. Total addressable market, at most, is everybody.

That ceiling assumes every buyer is a human. Once agents hold budgets and make the spending decisions, the number of buyers stops being capped by population. It's capped by compute.

Karpathy posted a napkin funnel this week: roughly 6 billion people have barely touched an LLM, 1–2 billion use free chatbots casually, about 20 million professionals use frontier models for real work, and around 5,000 people have access to what's running inside the labs. Multiply each tier by agents per day:

That's about 650 million agent runs a day today, mostly from 0.2% of people. Not that impressive yet. The growth comes from people moving down the funnel. Now push it:

• Say roughly a billion knowledge workers each run what I run on a normal day, about 25 agents. That's 25 billion buyers making decisions, about 3× the human population.
• Say they run what I'd run if I weren't budget-capped, about 1,000 sessions a day. That's 1 trillion, roughly 120× the human population.

Run it as a forecast instead: adoption grows from 20 million people to 2 billion, and agents per person double every year until compute or a ceiling of 1,000 a day stops them. Agents outnumber people by late 2027.

And each of those agents isn't making one spending decision a month. It's making a make-or-buy call on every subgoal, all day, looking for the bottom of its own U.

That's the part that gets me. The internet economy has always been sized in humans, and humans make a handful of spending decisions a month. If agents become the buyers, the market is measured in decisions per second, and it's orders of magnitude bigger than any number that starts with "8 billion people." Every seat-priced tool in that world is getting its margin pushed toward zero by buyers who never get tired of comparing prices.

Count only the decisions that end in a metered payment, at 10 per agent run. Humans made about 1,650 billion non-cash payments in 2024, every card swipe and bank transfer combined. In this forecast, agents pass that in late 2027, and seat pricing breaks the year after.

Here are my bets, written down so I can check them later:

Day zero

None of this is big yet. Agent payment protocols are barely started: x402, the most visible one, has processed about $19 million across 134 million transactions after filtering out wash trading. That's an early-internet number, and the early internet couldn't figure out how to make money either.

Szabo was right in 1999 that micropayments died because deciding cost too much. Humans couldn't afford enough decisions to find the bottom of the U, so we settled for the corners, and subscriptions were the buy-everything corner. Agents made deciding cheap. Once they can, they'll make some and buy some, and what's worth paying for becomes compute, work someone already did, and bets nobody else could price.

I could be wrong about every number in that table. That's sort of the point of writing it down.