← Back to blog

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

Same Page, Different Model: How the Embedding Model Changes the Match and the Bill
November 17, 2026by Dariusz Rozmus
AdtechEmbeddingsAgentic-audiencesOpenaiOpen-sourceContextualBedrockAgentic Audiences

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:

🔒 familytech.example/accessibility-settings
FamilyTechPhonesHomeFamily
IAB6-9 · Eldercare

Accessibility Settings Every Family Should Know

By the FamilyTech team · 3 min read

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

The ad: campaign brief
EasyCall

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.

Pick a modelinteractive
Click a row to see which sentences it reads ↑
Brief vs this page: how close EasyCall's brief is to the page above. Brief vs unrelated post: the same brief against a typical post with nothing about phones, for comparison. Vector length: how many numbers the model turns each text into, not the size of the model.
Highlights are measured, not simulated: we embedded the page again with one sentence (or the title) removed. The darker the highlight, the more that sentence ties the page to the brief for the chosen model. "Brief vs unrelated post": the median score of the brief against the other posts on this blog, none of them about phones. Page and brand are fictional.

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:

ModelFromVector lengthOne vector, 4 bytes each
text-embedding-3-largeOpenAI3,07212.0 KB
text-embedding-3-smallOpenAI1,5366.0 KB
text-embedding-ada-002OpenAI, previous generation1,5366.0 KB
bge-base-en-v1.5BAAI, open source7683.0 KB
all-MiniLM-L6-v2sentence-transformers, open source3841.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:

Build the requestinteractive
Switch vectors on and off: the request changes below ↓
Vectors in the request
POST /openrtb2/bid · one request, 3 vectors
{
"id": "req-2048",
"imp": [ … ],
1The auction. Request id and the ad slot for sale. Every bid request has these.
"site": { "page": "familytech…" },
2The page. Where the slot is. Usually also an IAB label (cat), as in part 1.
"user": { "data": [{
"name": "agenticAudience",
"segment": [
3Agentic Audiences. The extension’s container. Each segment in it carries one vector.
{ "ext": { "aa": { "type": [2],
"model": "text-embedding-3-large",
The model. Named next to every vector. A bidder can only compare vectors from the same model.
"vector": "vACgeTwAoPy7AKAAa2MsPct7Q7zO5eg7/9csO5tLdjzfv868XqX0u1idXbwHdp688dp4vAMhF7xpKKm77bKFvKzp+DuhdyG8ksRrvdSSrzxeJOe7OTlbvPdNnju2noc7…" }}},
4Page vector. Type 2, contextual: what the page is about. The one in all our examples.
{ "ext": { "aa": { "type": [1],
"model": "text-embedding-3-large",
"vector": "WfO9PL261Tx9gZw6HXlhvCkMobzU2hM6GreWvH/e07w0Hms7yFUdO/ooITw/xYa8cfG8OLe+mLokC968bakePMEpvTv7JDA9pG5vO6KyKrsGx7U88oBqO8YKhjxWm9e7…" }}},
5User vector. Type 1, identity: who is reading, without saying who they are.
{ "ext": { "aa": { "type": [3],
"model": "text-embedding-3-large",
"vector": "vXHfOtdSuDxbVom8/VSSPAbbmLvWPpq7HRAMPZrWOTvDikq6SyNXPFAppjxuiRG6C2gtPN2Uj7yCV9i7VTUBvAF0xLyAcN685uXvvGDDjLu+Zku7YPG8u7MXozqq8MS8…" }}}
6History vector. Type 3, reinforcement: what worked before, such as how similar readers responded.
]}]}}
vectors 3 × 12 KB = 36 KBrest of request ~3 KBvectors on the wire 92%
A trimmed OpenRTB bid request in the shape of the Agentic Audiences community extension. Switch vectors off to see the request with only some of them. Each vector is cut short and illustrative: in full, one text-embedding-3-large vector is about 16,000 characters (12 KB).

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:

Vector cost calculatorinteractive
Pick the settings: the request and the bill update below ↓

Estimate for 1 trillion bid requests a month.

Model
Vectors in each request
Each number takes
Where the bidder runs
Each bid request
89%is vectors
9.2× heavier than without them
page vector user vector the rest, ~3 KB
POST /openrtb2/bid
{ "id": …, "imp": […], "site": {…},
"user": { "data": [{ "segment": [
{"type":2,"model":"3-large","vector":"vACgeTwAoPy7AKAAa2MsPct7Q7zO5eg7/9csO5tLdjzfv868XqX0u1idXbwHdp688dp4vAMhF7xpKKm77bKFvKzp+DuhdyG8ksRrvdSSrzxeJOe7OTlbvPdNnju2noc712 KB
{"type":1,"model":"3-large","vector":"WfO9PL261Tx9gZw6HXlhvCkMobzU2hM6GreWvH/e07w0Hms7yFUdO/ooITw/xYa8cfG8OLe+mLokC968bakePMEpvTv7JDA9pG5vO6KyKrsGx7U88oBqO8YKhjxWm9e712 KB
]}]} }
benchmark: 1 trillion bid requests a month, one exchange → one DSP, $0.02 per GB
Single bid request size
~3 KB + 2 × 12 KB
27 KB
each vector: 3,072 numbers × 4 bytes
Data transfer
24 KB of vectors × 1T
24,576 TB
a month, vectors only, exchange to one DSP
Data transfer cost per month
× $0.02 per GB
$492k
per DSP
Benchmark: a round trillion bid requests a month from one exchange to one DSP. The default of two vectors per request (user and page) and $0.02 per GB on a private line at public list prices come from Damian Naglak, Bedrock Platform, IAB Tech Lab International Summit, London, 5 November 2026. A typical bid request without vectors: about 3 KB, the average AWS uses in its RTB Fabric pricing examples. Sent as base64 text in JSON, as in the bid request in part 1, a vector is a third larger again.

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:

Compare the billinteractive
Pick a model and the vectors: both lanes update below ↓
Model
Vectors
Size
Outside the exchange
ExchangeSSP
over the wire, every request
BidderDSP
~2,123 TB a day
$15.5M
a year, per DSP
~10 ms per trip
Inside the exchange, with Bedrock
SSP infrastructure· one machine
ExchangeSSP
in memory
Bedrock biddercontainerised
0 TB on the wire
$0
saves $15.5M a year
~1–18 µs per tripup to 10,000× faster
Outside the exchange
2 vectors × 12 KB × 1M requests a second = ~2,123 TB a day × $0.02 per GB = $15.5M a year, ~10 ms per trip
With Bedrock inside the exchange
0 bytes over the wire = $0 → saves $15.5M a year
~10 ms → ~1–18 µs per trip → up to 10,000× faster
Assumptions from Damian Naglak, Bedrock Platform, IAB Tech Lab International Summit, London, 5 November 2026: one exchange and one DSP at a million requests a second, a private line at $0.02 per GB, public list prices. Compressed means one byte per number instead of four. Time per trip: about 10 ms over the network, from the same talk; on one machine, Bedrock’s measurements of a request and its answer, about 18 µs through the operating system and about 1 µs through shared memory with the bidder polling for new requests.

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

Rule 1
Calibrate every model

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.

Rule 2
Test on your own pages

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.

Rule 3
Send the model with the vector

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.

Rule 4
Count the bytes

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.

Struck through: the usual way. Below it: what the comparison in this post suggests.

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 →

Share: