Turbnetic Research  ·  Note 01

The LLM economy needs its own AdSense

Abstract

I think most people will never pay for a frontier model directly, the same way most people never paid for YouTube. A lot of them learned to code on the free version. If we want the same thing for AI, someone has to fund the free tier, and right now the only party that can is the one company running its own closed ad system. This note is my attempt at the open version: how an ad gets picked and paid for on an LLM turn, on hardware nobody trusts, without the conversation leaving the machine and without the ad being able to change the answer. There is a working reference implementation; the link is below.

Musa Aghayev  ·  September 2026  ·  github.com/musa92/uap
01The economy

Where the humans are

The LLM economy is settling into layers. At the top is question and answer: a person types, a model answers. Below that, agents do the actual work, calling tools, hitting APIs, talking to other agents. At the bottom, renderers turn all of it into something a human looks at.

Humans only touch the QA layer directly. Everything under it is bots talking to bots. That matters for advertising, because it tells you where an ad can honestly live. At the QA layer it looks like what ChatGPT already ships: a labelled sponsored unit under the answer. At the agent layer it looks different. An agent booking travel or picking a database is going to choose a vendor, and a vendor can pay to be one of the options, as long as it is disclosed and the organic options are still there untouched.

Both of those are real inventory. Today both belong to one seller.

ChatGPT started serving sponsored links under answers in February 2026: about $100M annualised inside two months, at roughly a $60 CPM.2 An LLM turn prices like paid search, because the person just told you what they want in their own words. Everyone else running a model gets none of that and pays for the GPUs anyway.

02Why free

The YouTube argument

I keep coming back to YouTube. Nobody paid to learn coding there. The ads paid, and a generation of engineers came out of it. AdSense did the same thing for the written web in 2003:1 paste a snippet, get paid, no sales team. It did not make bloggers rich. It made publishing cheap enough that people kept doing it.

That is the trade I want for models. Not that providers get rich off ads. That ad revenue covers the compute, so the consumer side of a frontier model can be free, and the people who most need it, students, people in countries where $20 a month is real money, get the same model everyone else gets.

Free on the consumer side is not charity. It is what the ad revenue is for.

The provider side is the part that has to be motivated. If you run an open-weights model on your own hardware today there is no way for the value of a turn to reach you. Fix that, and serving open models stops being something you do at a loss until you get tired of it.

03The unit

What it looks like, and how it gets paid

The unit is boring on purpose: the answer, a hard line, then a labelled block the model never saw. All the interesting parts are the things that cannot happen.

Figure 1A served placement, and the guarantees around it
YOU
I want to book a ryokan in Kyoto in November. What should I expect to pay?
AI
Kyoto ryokan rates peak in November for the autumn foliage. Expect ¥25,000–¥60,000 per person per night with dinner and breakfast included. Book two to three months ahead; the well-known machiya inns in Gion sell out first.
Sponsored
Sponsored · Acme Travel

Kyoto ryokan, free cancellation

Traditional inns from $180 a night, cancel up to 24 hours before arrival.

See rooms
1
The answer finished first. Its bytes were hashed and the digest sent to the exchange before the auction ran. At that moment no winner existed, so the answer cannot have depended on one.
2
The creative was never in the model's context. It arrives as structured fields, is escaped to inert text, and is stripped before any summarisation or re-feed.
3
The separator is not decoration. Disclosure is a billing precondition. An unrendered label makes the impression non-billable, not merely non-compliant.
4
Nothing about the conversation left the machine. Targeting was derived on the node and reduced to a closed taxonomy. No free-text field, no identifier stable across sessions.
The thing that joined the answer and the ad is a plain function. It is not a model and it cannot rewrite anything. If you have the answer, the decision and this output, you can recompute the bytes yourself and check nothing was touched.

Underneath, one turn becomes one settled impression like this. The part I spent the most time on is the allocation: the exchange promises you a slice up front, and if you serve inside it you are paid. No more serving in good faith and finding out at settlement that the campaign ran out somewhere else.

Figure 2How one turn becomes one settled impression
EXCHANGE SERVING NODE SURFACE HOURLY PER TURN · ZERO NETWORK CALLS LATER Sign bundle identical for every node targeting · creatives · prices Sign allocation this node's slice per line item sum over nodes ≤ budget Verify signature nonce derives digest matches index < slice trace replays price derived then settle Cache and compile predicates compiled once served for the hour Generate to completion COMMIT hash answer before selection Auction local, from cache 0.66 ms / 1,000 Compose answer ‖ separator ‖ creative · deterministic · never a model Render, measure, sign receipt MRC viewability · disclosure is a billing precondition nonce derived from bundle, node, line item and index batched · delayed · shuffled two signed objects down nothing leaves receipts up, no context
This is the local mode, the one I care about for self-hosted models. Two signed files arrive on a schedule. The turn itself makes no network call at all. What goes back is a receipt the surface signed, and the exchange recomputes every number in it from what it issued instead of trusting the node. If you serve inside your allocation you get paid, full stop. If the exchange allocated wrong, that is the exchange's loss, not yours.
04The math

Does it actually cover the compute?

I did not want to argue about this, so I worked it out from the hardware.

Cost. A 70B-class open model, fp8, batched, on an H100 at about $2 an hour, does roughly 3,000 output tokens a second. A turn of around 400 output tokens costs $0.000074 to decode; 1,200 input tokens add about a quarter of that in prefill. Call it $0.000093 a turn, nine cents per thousand.

Revenue. At a CPM of p, one ad every L turns, and the node keeping 65 percent, you get 0.65p / 1000L per turn. Set that equal to cost and the break-even CPM is 0.143 × L: $0.43 with an ad every three turns, $1.42 every ten, $2.85 every twenty.

The market pays about $60. So this was never a question of whether ads can pay for inference. They pay for it a hundred times over. The question is whether the money can reach the person running the hardware without them having to build an ad business first.

Figure 3How far ad revenue covers the cost of serving a turn
Log scale because the gap is two orders of magnitude. One ad every twenty turns at a twentieth of today's CPM already covers the compute. Every curve crosses break-even under $3.

The model author gets a cut too

Open-weights models are a public good with no revenue behind them. Every node downstream captures the value. In this design the model's own manifest at /.well-known/uap-model says what ads it allows and what share it wants, and the exchange enforces it because the exchange is the one holding the money. An author who wants none of it sets permitted: false and no conformant exchange will clear an auction on those weights. That is a veto and a royalty on traffic they never see.

Plug in your own numbers:

$13k
node / month
$3k
model steward
500k
impressions
9
H100 months
05The one rule

The ad cannot touch the answer

An ad that pays per click, sitting next to text a model generates on the spot, is pressure to bend the text. Retail media already shows what happens: studies put 30 to 40 percent of sponsored-product sales down to purchases that would have happened anyway.4 Ipsos found about two thirds of US adults trust AI answers less when there are ads in them. A surface that bends its answers ends up at display CPMs.

So the protocol draws a line and makes it checkable, not just promised. The node hashes the answer and sends the digest to the exchange before the auction runs. At that moment no winner exists, so the answer cannot have depended on one. The composer that joins answer and ad is a plain function, so anyone can recompute the bytes:

from uap import verify_composition, verify_answer_commitment

verify_composition(rendered, answer, decision)
#  (True, 'composition is exact')
Figure 4The boundary, and the one function permitted to cross it
MODEL PATH ADVERTISING PATH Model context system · history · user turn nothing purchased is ever placed here generate to completion Organic answer verbatim bytes, final COMMITMENT SHA-256 of the answer bytes recorded before any auction runs ADS MAY NOT CROSS ContextSignal closed enumerations, bounded numerics no free text, no stable identifier Auction bids never reach decoding or routing Creative structured data, escaped to inert text COMPOSER deterministic · never a language model · concatenates, does not rewrite Surface renders · measures viewability · signs the receipt the exchange bills against
Without this line, an ad slot is the cheapest prompt injection there is, and the publisher gets paid to host it.

The exchange also holds out a slice of requests: same path, no ad served, digest still reported. If the served answers drift from the held-out ones, something is bending them. No single receipt can show that; the holdout can.

06Stability

Making it something providers can rely on

Motivation is not enough on its own. Providers will only plan around this if payment is predictable, so the parts I built first are the ones that make it stable.

BuiltWhat it guarantees
Signed allocationsServe inside your slice and you are paid. Slices across all nodes cannot exceed the budget, so over-allocation is the exchange's loss.
Receipts recomputed, not trustedNonce, digest, price and pacing are all rederived at the exchange from what it issued.
Steward share enforcedThe model author's cut cannot be reduced by the node or the exchange.
Buy sideCampaigns, creative review, forecasting, conversions, aggregate reporting. Agencies can spend without a private arrangement.
Integrity, provableAnswer digest committed before the auction; composition anyone can recompute; a holdout arm.

Still open: the billing lifecycle, invoicing and disputes and make-goods. A production classifier; the one that ships fails closed on purpose, so it serves nothing until someone replaces it. And frequency capping across nodes, which I do not have a design for yet, because doing it network-wide needs an identifier the protocol forbids on purpose.

The honest part

Nobody runs an exchange yet. Supply will not show up without demand and demand will not show up without supply, and a spec does not solve that. Somebody has to run all three roles in one narrow vertical until there is inventory worth bidding on. That is how every ad network started, including the closed one this is a response to. I would like that to be an open one.

If you want to attack something, attack the k-anonymity floor, whether the bundle fetch leaks anything about a node's audience, and whether the unattested tier has any honest demand. Those are the parts I am least sure about.

References
  1. Google, "Google Expands Advertising Monetization Program for Websites", 18 June 2003.
  2. Reported ChatGPT advertising revenue and CPM, February to April 2026. See Advertising on AI Platforms, 2026.
  3. Global digital ad spend 2026. See Digital Ad Spend Statistics 2026.
  4. Retail media sponsored-product cannibalisation estimates. See eMarketer, Amazon advertising FAQ.
  5. AdCP and IAB Tech Lab AAMP work above real-time bidding, at the campaign layer. UAP is the serve-time layer under both.