Same Page, Different Model: How the Embedding Model Changes the Match and the Bill

In part 1 and part 2 of this series every vector came from one embedding model, OpenAI text-embedding-3-large, and the bid request carried the model's name next to the vector, in the model field that the Agentic Audiences extension to OpenRTB defines for every vector. This post is about why the model matters.
We took one page and one ad from part 2 and ran them through five models: three from OpenAI and two open-source ones you can run on your own servers. Then we looked at three things: the results, the length of the vectors, and what that length costs.
One page, one ad, five models
The page is a guide to accessibility settings on a family tech site. The ad is EasyCall, a simple phone for older people. Pick a model to see how it scores the pair, and which sentences of the page tie it to the ad:
Accessibility Settings Every Family Should Know
Every phone, tablet and TV hides settings that make it easier to use for someone whose eyes, ears or hands are not what they were.
Turn on larger text and bold fonts, and raise the contrast so buttons stand out.
Make calls louder and switch on hearing aid mode.+0.026
Set up emergency contacts that can be reached from the lock screen with one press.+0.011
Slow down double taps, and let the device read messages aloud.
Ten minutes with a parent's phone can save months of frustration.+0.019
EasyCall makes simple phones for seniors: big buttons, a large clear screen, loud sound, hearing aid compatibility, an SOS emergency key and a long battery, at a low price. Campaign: a phone for mum and dad. Audience: older people and their adult children looking for an easy to use, affordable phone for an elderly parent.
Every model agrees that the page and the brief belong together: each scores the pair well above what it gives an unrelated post. But the numbers themselves are far apart, from 0.43 with MiniLM to 0.86 with ada-002. And ada-002 gives unrelated posts about 0.71, more than MiniLM gives this good match. A similarity score means nothing on its own; it only means something against that model's own idea of "unrelated".
The models also notice different things. Four of them hold on to "Make calls louder and switch on hearing aid mode", which echoes the brief's loud sound and hearing aid compatibility. MiniLM barely registers that sentence and holds on to "a parent's phone" instead, which echoes the brief's phone for mum and dad. The opening sentence about eyes, ears and hands pulls the page away from the brief for three models and towards it for the other two. Each model weighs words its own way. On a clear page like this one they still agree on the answer; on a page close to the line, they won't always.
Five models, five lengths
The models also turn a text into lists of very different length. That length is the vector's dimension, how many numbers describe one text, not the number of parameters inside the model:
| Model | From | Vector length | One vector, 4 bytes each |
|---|---|---|---|
| text-embedding-3-large | OpenAI | 3,072 | 12.0 KB |
| text-embedding-3-small | OpenAI | 1,536 | 6.0 KB |
| text-embedding-ada-002 | OpenAI, previous generation | 1,536 | 6.0 KB |
| bge-base-en-v1.5 | BAAI, open source | 768 | 3.0 KB |
| all-MiniLM-L6-v2 | sentence-transformers, open source | 384 | 1.5 KB |
The numbers can't be mixed. Each model arranges meaning its own way, so a page vector from one model can't be compared with a brief vector from another, even when both have the same length, as text-embedding-3-small and ada-002 do. That is why the extension gives every vector its own model and dimension fields, and why a bidder has to embed its campaign brief with the same model the publisher used for the page.
One request, several vectors
So far every bid request in this series carried one vector, for the page. The Agentic Audiences community extension to OpenRTB, part of IAB Tech Lab's Agentic Audiences standard, allows more. Each vector travels as its own segment in user.data, built from OpenRTB's standard Data and Segment objects, and the extension's type field says what it describes: 2 for the page (contextual), 1 for the user (identity) and 3 for what worked before (reinforcement), such as how similar users responded to ads. None of them is required. A request can carry only the page vector, as in the earlier parts, only the user vector, or any mix of them.
Below is a request with all three; switch any of them off and the request shrinks with it:
Each one is another full vector, from whichever model produced it. On the sell side this is already practical: Prebid has an Agentic Audiences module that adds such segments to the bid request.
Length is a cost
A vector sent with a bid request crosses the network with every request. At the volumes of a real exchange, that adds up fast. Damian Naglak, CTO of Bedrock Platform, walked through the numbers in his talk at the IAB Tech Lab International Summit in London: at a million requests a second, with a user vector and a page vector in each request, a DSP receives hundreds of terabytes a day, at about $5M a year on a private line, before any discount.
To put that in proportion: a typical bid request weighs about 3 KB, the average AWS assumes in the pricing examples for its RTB Fabric bidding network. Add a user vector and a page vector, and most of what crosses the wire is suddenly vectors. The calculator below runs the same sum on a fixed benchmark: one trillion bid requests a month between one exchange and one DSP. Tick the vectors your request would carry and pick a model:
Estimate for 1 trillion bid requests a month.
With two 3-large vectors at full precision, about 90% of every request is vectors, and the request is nine times heavier than without them. A 3-large vector is eight times the size of a MiniLM one, and the bill grows with it. Fewer numbers, or one byte per number instead of four, cut the bill four to sixteen times, at some cost in precision. Switch the bidder to inside the exchange and it drops to zero.
The cheapest vector is one that doesn't travel
Every number above assumes the bid request crosses a wire between the exchange and the bidder. That is how most bidders run today: the exchange packs each request, sends it out, waits for the answer and pays for every byte on the way. A vector makes each request several times heavier, and the bill grows with it.
Bedrock Platform takes the wire out. Its bidder runs in a container inside the SSP's own infrastructure, next to the auction. The bid request, vectors included, never leaves the exchange, so there is nothing to ship and nothing to pay for. That is what Bedrock saves: not a discount on the transfer bill, the whole bill. Damian Naglak's talk put it at about $5M a year per DSP for two vectors of 1,024 numbers; with two 3-large vectors it is three times that. Pick a model and the vectors, and see what the saving comes to:
The vectors stay the same, as do the model and the match. What changes is where the bidder sits, and with it the transfer bill. Time changes too. Over the network, a request and its answer spend about 10 ms on the road. On one machine they pass through memory in microseconds, so those milliseconds go back to the bidder's model. And the bidder sees every request instead of a throttled share of them, so richer signals such as vectors stop being a cost and become something to use.
What to take from this
One threshold for "related", reused across models.
Unrelated posts score 0.71 with ada-002 and 0.06 with MiniLM. Measure each model’s own baseline.
Pick the model by benchmark score or price.
Four models held on to the hearing-aid sentence, MiniLM to the parent’s phone. Check what each one notices on your inventory.
A vector on its own, from whichever model.
Vectors from different models can’t be compared, so the model’s name travels with every vector.
The biggest model at full precision, shipped with every request.
From 12 KB a vector (3-large) to 1.5 KB (MiniLM), or a bidder inside the exchange so it never travels.
Embeddings make contextual matching far more precise than labels, but a similarity score only means something next to the model that produced it, and every number in a vector has a price in the bid stream. Picking the model, calibrating it on your own inventory and deciding where the vectors travel is where most of the engineering is.
It is also the work we do every day at Appliscale, from bidders inside and outside the exchange to SSP, DSP and Prebid integrations and the pipelines that embed pages and briefs.
If you'd like to explore what embeddings could add to your ad stack, we'd be glad to help. Talk to us →