The Signal Landscape — Probabilistic Audience Activation

How the campaign bets on users nobody knows

By Luca Passani, @Scientia_CTO, August 2026

Note: this article assumes that you are familiar with multiple programmatic/ad tech concepts. If not, make sure you read the previous installments. At the very least, you should read the previous two articles, article on ID providers and identity graphs and deterministic audience activation. The itinerary for this installment: I’ll show what happens to Sloane’s bid request when the login never happened. That’s the context in which the probabilistic machinery churns out its educated guesses. Understanding the principles of probabilistic systems demands a short detour through machine learning (no math required, I promise). Finally, I’ll show two real products that put those principles into action. To close, we’ll count the users this machinery still cannot reach and why this count matters.

The previous article followed a logged-in reader, Sloane, through deterministic activation: our fictional advertiser (House of Frada) identified Sloane as its past (and beloved) customer and successfully targeted her with its campaign. Our fictional example is too useful to let go, though, so I’ll go for a little Sliding Doors moment. In the 1998 film, the fork between two parallel timelines was catching or missing a train; in our story, it’s Sloane being logged in… or not.

Request #7f3a9c2e hits The Shade Desk (our fictional DSP) room again, this time in a parallel universe where Sloane never logged into the Gotham Times. Same woman, same phone, same fashion article, but no login event, so no email, no UID2, no RampID. Frada’s clean room output has nothing to attach to. What’s missing is everything the deterministic pillar was built on. In other words, this Sloane is not addressable. 

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  BID REQUEST  #7f3a9c2e  (parallel universe)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━


INVENTORY

Publisher        The Gotham Times
Page             gothamtimes.com/section/fashion
Ad slot          Leaderboard 970×250, above the fold
Floor price      $4.50 CPM
Content tags     Fashion, Style, Luxury

USER

UID2 token       — (no login, none issued)
RampID token     — (no login, none issued)
Year of birth    —
Gender           —
Location         Manhattan, zip 10013
Privacy          GDPR: not applicable | US privacy signal: not opted out

AUDIENCE SEGMENTS (publisher-declared, modeled)

gotham_luxury_fashion        confidence 0.81  ✓  ← cohort model output
gotham_frequent_reader       confidence 0.88  ✓

ACTIVE CAMPAIGNS MATCHED

┌─────────────────────────────────────────────┐
│ Strada by Frada — New Collection Launch     │
│ (prospecting line)                          │
│ Target: luxury_fashion cohorts              │
│ Max bid: $6.50 CPM                          │
│ Budget remaining: $48,400                   │
└─────────────────────────────────────────────┘

DEVICE

Type             Smartphone
Make             Apple
Model            iPhone 17 Pro
OS               iOS 26.5
Screen           402×874 px @3x resolution
Connection       T-Mobile
Location         SoHo, New York City

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

To be clear, this is far from a rare occurrence: it’s the default condition of the open web. Most viewers are not logged into the publisher’s website, and there is money in squeezing whatever signal remains out of that anonymous traffic. That’s why the industry developed probabilistic techniques — a way to claw back some addressability for the majority of the audience that the deterministic pillar cannot reach. In short, the question shifts from “who is this?” to “what kind of viewer is this?”, from “we know it’s you” to “we’re 81% sure this browser belongs in the luxury-fashion crowd”.

Here are the key differences between the two bid requests:

• USER tokens: gone. No login means no UID2, no RampID, and year of birth/gender lose their (inferred) basis.
  
• Segments: there were six, now there are only two, renamed with a gotham_ prefix, header changed from (from identity graph) to (publisher-declared, modeled).  The DSP resolved nothing; the publisher is asserting now.
  
• Confidence: from 0.96 to 0.81. Direct observation is replaced by a model’s guess.
  
• frada_crm_match: is gone. No identification means no CRM match.
  
• Campaign: the previous retargeting line ($22.00) won’t fire; the prospecting line fires at $6.50.  To reiterate: the same slot for the same person commands about three times less money without identification.

Note: Of course, the device information stays the same in both universes. Device type identification is generally not based on PII.

Note: it’s worth giving names to the three states a user can be in, as seen from the machinery’s side.
Identified: the original Sloane — logged in, tokens minted, the machinery knows who she is.
Observed: parallel-universe Sloane — the machinery has watched this browser read twelve fashion articles, but has no idea who is behind it.
Stranger: neither — imagine Sloane on a brand-new phone, first visit, private browsing: no identity, no history, nothing.
Together, the identified and the observed are the users the machinery can recognize at all, the addressable ones. The stranger is recognized by nobody. Keep these three words (this taxonomy) in mind; the rest of this article maps onto them.

Note: You may have noticed websites greeting you with “Sign in, Luca” or “Luca — not you?” The site is confident enough that this is your browser to prompt you with your name, but not confident enough to let you perform certain operations without full authentication. Advertising identity is born of the second kind of confidence but lives on the first. That’s because the browser holds two different pieces of first-party state with two different lifetimes: a short-lived session cookie that guards your account, and a long-lived one that remembers which account this browser belongs to. Identity tokens like UID2 or RampID are minted at an authentication event and then live a life of their own — the machinery never asks whether you’d pass the password wall right now. How long identity is allowed to outlive the login is a publisher policy choice: some pass tokens only during an authenticated session, but many keep passing them for as long as user consent is valid. This should come as no surprise now that you understand the incentives at play: the share of “authenticated” traffic is publishers’ gold with SSPs and buyers. The password wall protects the account. That the person at the keyboard might not be Luca on rare occasions is a risk the programmatic apparatus happily absorbs.

It’s time to look at the basic concepts of probabilistic modeling. To be perfectly clear, this is the realm of data scientists and their machine learning techniques. I intend to deliver the gist of the technology in the easiest possible way without overwhelming you with too much information. Please stay focused. Those basic concepts will let us take a high-level look at what specific industry products offer and you’ll have the tool to make sense of similar solutions in this area.

Probabilistic Audience Modeling: The Machinery

Imagine giving a medical student hundreds of completed practice exams to study. After hours of meticulously cross-referencing the data and looking at who got sick, our future doctor develops a sixth sense that lets them tell apart the patients who will stay healthy from those who might develop cancer mostly correctly. Now scale the exercise up by four orders of magnitude — millions of patients, hundreds of measurements each, correlations too faint for any human to spot across so much data — and you have left human territory. This is where Machine Learning lives.

Thanks to Machine Learning, computers can do a lot better than humans in tasks like this today. Imagine a massive digital archive containing a decade’s worth of routine patient data—blood panels, metabolic tests, and routine imaging exams. By itself, this mountain of data is just noise. Imagine the data is augmented with the eventual outcome: which patients went on to develop cancer years later, and which stayed healthy. This historical outcome is the Ground Truth. It is the absolute, verified reality of what happened.

Researchers can now feed the computer the old lab results (the questions) alongside the patient’s final health outcome (the correct answer). The computer cross-references the data, looking at the patient who got sick and finding the exact, microscopic point where their blood chemistry began to deviate from the patients who stayed healthy.

Note: in Machine Learning jargon, a feature is a single measurable input signal the model uses to make a decision. Think of it like one column in a spreadsheet or dataset. Models learn from features; remember the word.

Figure: ML techniques learn an algorithm from historical data with known “ground truth”. The trained algorithm can then make predictions on new, unlabeled data.

This is Machine Learning (ML) in action. This process is called training the model. Data can be used to generate a magical algorithm, i.e. a somewhat black-boxy “software oracle” that will look at the results of the same tests for an arbitrary patient, and will return an estimate of the chances that that patient will develop cancer later in life. A trained ML model can predict, allowing it to look at a brand-new patient’s lab results today and flag the hidden footprints of cancer before it spreads.

Note: This training method is called Supervised Machine Learning. And yes, “unsupervised machine learning” is a thing. That’s when researchers have the data but no ground truth (i.e. no answer column) and the algorithm has to find structure on its own.

Now that you understand the general gist of what machine learning can do, grasping how the same technology can be applied to users’ online behavior is within reach. In programmatic, machine learning doesn’t just run once. It runs as an assembly line of inferences continuously converting sparse, anonymous breadcrumbs into structured audience segments (cohort assignments). 

Trained where identity exists, applied where it doesn’t
You need a foundation of ground truth to build ML models. Programmatic offers plenty of that. Data scientists just need to select a minority of traffic that contains user IDs (such as the publisher’s logged-in users or a brand’s known online converters) to decipher those users’ underlying behavioral signatures. Once the models are built, they can project their statistical patterns onto the vast, anonymous majority of new and future users.

Features are behaviors, not identifiers
The variables fed into these models are transient observational signals rather than persistent identities. The feature set ingests the sequence and frequency of page visits, content categories, recency, time of day, coarse location, and device attributes. Nothing in this dataset names a person or assigns a cross-site tracking token — the algorithm isn’t trying to remember who you are, but rather deduce what kind of user you are acting like right now. 

Note: to visualize Machine Learning in action, snap a picture of any item on your desk with your phone, upload it to Google Lens and watch it tell you that it’s a cup, or an apple or a pack of gum that you just uploaded. Nobody ever saw that picture, but ML models can decompose your image in “signals” that let a computer identify the object even without ever seeing that specific image before. 

Probabilistic Audience Modeling: The Epistemology

Epistemology is the study of how we know what we claim to know — what makes something actual knowledge rather than just a guess, and how we can justify it. 

Note: If it sounds like a term out of a long-forgotten Philosophy class, it’s because it is. As AI takes over all aspects of human activities, you’ll find that the question about how we know what we think we know will be increasingly important.

The output is a probability, not a fact
A value like confidence 0.81 is not a statement of truth; it is a statistical claim about likelihood. In this framework, the confidence score acts as an operational business dial: 

• if an advertiser lowers the threshold to 0.50, its target audience expands dramatically. The flip-side of this decision is the increase of false positives. In practice, advertisers will pay to show their ads to users that are not interested.
  
• if an advertiser raises the threshold to 0.95, the precision skyrockets, but your overall reach collapses (very few users are shown the ad).

While deterministic matching offers a binary, black-and-white outcome (matched or not matched), probabilistic modeling forces every buyer and seller to manage a continuous trade-off along that accuracy-versus-scale curve.

Figure: Probabilistic Modeling is the art of choosing where to draw the line, i.e. the Confidence Dial (Deterministic activation didn’t have this problem!). The figure shows the trade-off. At 0.50, ‘huge reach’ means you’re including almost everyone who looks remotely interested (i.e. everyone to the right of the red line), BUT, at the same time, you’re also paying to reach many who aren’t. At 0.95, ‘almost pure’ means you’re only targeting the sure things, but you’re ignoring a large pool of genuinely interested users who didn’t score high enough. The dial is where you decide which cost you’d rather bear.

Note: if you ever took a course in statistics, you’ve likely already heard terms like Confusion Matrix, False Positive, True Negative, Precision, Recall Rate, and others. That theory is the foundation to many Machine Learning techniques.

Cohorts, not individuals.

The main point about the probabilistic approach is that it’s not about a single person. The fundamental unit of output is membership in an aggregate group that meets or exceeds a minimum size threshold. This achieves the exact same k-anonymity logic enforced by a data clean room’s minimum-cohort rules, except it arrives at privacy from the opposite direction. Instead of taking individual records and locking them down, probabilistic modeling groups broad behavioral patterns together so that no single user is ever singled out.

Probabilistic Audience Modeling: The Economics of Trust

Assertion, not resolution.

There is one more difference between the two pillars, and it’s the easiest to miss: how claims get verified. A deterministic match comes with a receipt. When House of Frada onboarded its customer file in the previous article, the clean room handed back a match-rate report. The number may disappoint, but nobody has to take anybody’s word for anything: the mechanism itself did the counting, hashed email against hashed email.

A modeled segment comes with no receipt. When the Gotham Times declares that an anonymous browser belongs to its luxury-fashion cohort with confidence 0.81, there is nothing for the buyer to verify. It’s an assertion. In fact, the model itself never learns whether it was right — there is no answer column for anonymous traffic, which is exactly why a model was needed in the first place.

So when The Shade Desk bids on that segment, who is it trusting? Not the mechanism. The modeler. If the segment is publisher-declared, the buyer is trusting the Gotham Times: its data, its model, its name on the label. If the segment was built by a specialized vendor and packaged behind a Deal ID, the buyer is trusting that vendor’s methodology instead. 

Note: a Deal ID is a label agreed in advance between a seller (or a curation specialist) and a buyer; once appended to a bid request, a Deal ID tells the buyer “this impression belongs to the package we negotiated” (a curated cohort, for example). I’ll illustrate Deal IDs in a future article on curation and traffic shaping.

That’s why our fictional bid request labels its segments ‘publisher-declared’. In the real OpenRTB payload, every segment arrives inside a data object that names its source, so the buyer always knows who is making the claim.

Of course, selling “inflated segments” might be an incentive for publishers, SSPs and curation companies. This is why, in the probabilistic world, who makes the claim matters as much as the claim itself. Publishers understand this very well: a publisher caught selling inflated segments doesn’t get fined, but it may get “discounted”, i.e. quietly downgraded in buyers’ models, which can measure how little bang advertisers are getting for their bucks. 

Note: I find this similar to how credit rating companies work for consumers in the US. A missed payment will follow a consumer around without them immediately realizing.

DCRs’ Role in Probabilistic Audience Modeling

At this point, I wouldn’t want you to walk away with the (wrong) impression that DCRs sit squarely in the deterministic field. DCRs are also used to build the seeds that probabilistic modeling feeds on. Picture this workflow: a brand onboards its customer file into a clean room, matches it against a publisher’s audience, and the matched portion — a few thousand verified, known users — becomes the seed. 

Note: if the term “seed” in this context reminds you closely of what data scientists call ground truth, your intuition is exactly right. Seed and ground truth is essentially the same concept.

From there, the probabilistic machinery takes over: a lookalike model trained on that seed goes hunting for the anonymous millions who behave the same way. Some clean rooms even run the lookalike modeling inside the room, so that the seed itself never leaves. Seen this way, the two pillars are not rivals but stages of the same pipeline: one manufactures the ground truth, the other spends it. If I gave you the impression that the industry picked a side in some deterministic-versus-probabilistic contest, that’s an artifact of how these two articles are organized, not of how the machinery actually runs. Showing the two pillars separately makes explaining them easier, but please keep in mind that DCRs are versatile tools that can address multiple use cases.

From Theory to Practice: Seeding an Audience

Time to see how all of this theory was translated into commercial products. Because of what I just wrote, the term seed audience should already make sense to you. The seed is the ground truth, i.e. the small group of users a company already knows something about, and it’s where every probabilistic campaign starts. A brand will hand the model a few thousand users who are definitely the kind of people they want (Sloane is one of them). The model goes looking for the millions who behave like them. The industry calls this expansion lookalike modeling, and it is the bread and butter of everything that follows.

Note on vocabulary: Different vendors use different terms. You will see seed audience, seed cohort, seed segment and sometimes just seed list. These are all the same thing. What actually (and crucially) varies is whose seed it is. On the publisher side, the seed might be logged-in subscribers or readers who declared an interest. On the brand side, it might be existing customers, site visitors or recent converters. Keep that question in mind (“who owns the seed?”) because it decides who the modeler is — and, as we saw in the previous section, the modeler is who the buyer ends up trusting.

Permutive and Dstillery sit at opposite ends: publisher-side and buyer-side respectively.

Permutive: modeling from the publisher’s seat.

Permutive is a name you’re likely to hear in publisher-side audience modeling, and its architecture is worth understanding because it maps onto nearly everything I have discussed so far.

Permutive’s model runs “at the edge”, i.e. inside the visitor’s browser. This is a pretty smart move: a publisher’s first-party signals never leave the device. What this browser reads, how often it comes back, how deeply it scrolls: all of that stays local. The only thing that leaves the browser is the conclusion, i.e. “this browser belongs to cohort gotham_luxury_fashion”. 

Interestingly, “don’t move the data, move the computation to where the data lives” is a concept that some of the clean rooms also adopt. In this case, the data lives in the browser, so that’s where the model runs. Since nothing depends on third-party cookies, the approach keeps working in places where identity-based targeting goes blind. One caution though: the richer cohorts need a behavioral trail, so the natural habitat of this machinery is the observed user (ref.: the identified-observed-stranger taxonomy). On a first visit, the model can only work with what the current session shows, which is much thinner. The stranger is not entirely invisible here, but she is close.

Let’s call on The Gotham Times once more to see how they’d leverage Permutive based on their access to rich first-party interactions.

Step 1: Generating the Publisher’s “Ground Truth” (The Seed) 

• The Seed Population: The Gotham Times identifies 5,000 logged-in subscribers who explicitly declared an interest in luxury fashion or regularly read exclusive haute-couture reviews. This group serves as the ground truth.
• Feature Extraction: Permutive’s code running on the site monitors how these seed users interact with the publisher’s digital properties:
  • Content Taxonomy: Reading articles tagged under Fashion, Haute Couture, or Designers.
  • Behavioral Depth: Scrolling through at least 80% of long-form fashion articles, spending 90 seconds or more on a page, and visiting the fashion section 3 or more times a week.
  • Session Dynamics: Reading on high-end mobile devices during evening hours.

Note: Feature extraction is turning raw, messy data into clean features the model can actually use, i.e. the ML “information distillation” process we explained above.
In this context, Taxonomy means the organized list/tree of all possible labels you allow the model to choose from.

Note: if you happen to know what contextual targeting is, you might notice that some of these features look contextual. That’s a sharp observation, but I think you are better served by not conflating probabilistic and contextual targeting. More on this in a bit. 

Step 2: Training the Edge Model

Permutive’s machine learning platform analyzes this seed behavior and creates a compressed, mathematical Lookalike Model. Instead of uploading user data to a cloud database, The Gotham Times deploys this model directly into the JavaScript running on its website.

When a brand-new, completely anonymous user visits the website, Permutive’s script evaluates their behavior on the device, in real time.

Step 3: Real-Time On-Device Inference

An anonymous user (say, someone using Safari with no third-party cookies, no RampID, and no login) opens an article on The Gotham Times and Permutive’s script observes this behavior.

•   Session 1: Reads “Spring Fashion Week Preview” (scrolls 100%, stays 2 mins)
•   Session 2: Reads “Milan Leather Trends” (clicks photo gallery)
•   Current Time: 8:30 PM

Here is what happens under the hood:

1. Zero Data Leaves the Device: Permutive’s local script observes these events in the local storage on the device.
2. Local Model Scoring: The model compares this anonymous user’s local behavioral signals against the statistical footprint of the luxury seed population.
3. Cohort Assignment: The algorithm calculates a 0.88 confidence score that this user belongs in the gotham_luxury_fashion audience group.

Step 4: Injecting the Signal into the Auction

Because the computation happened instantly on the user’s device, the cohort assignment is ready before the ad auction even fires.

When The Gotham Times sends the bid request to the SSP and DSP, it attaches the publisher-declared cohort:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  BID REQUEST  #8d7e6f5a  (The Gotham Times)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
INVENTORY
  Publisher      The Gotham Times
  Page           gothamtimes.com/section/fashion
USER
  UID2 token     — (none)
  RampID token   — (none)
AUDIENCE SEGMENTS (Publisher-Declared / Edge Modeled)
  gotham_luxury_fashion        confidence 0.88  ✓  ← Permutive Output
  gotham_frequent_reader       confidence 0.88  ✓
━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The Shade Desk (our fictional DSP) receives the request. It sees The Gotham Times declaring a high-confidence luxury fashion cohort and bids $6.50 CPM. This, by the way, is how gotham_luxury_fashion ended up in parallel-universe Sloane’s bid request earlier: same machinery, different browser, different score. Takeaway point: the publisher monetizes a Safari impression that would have otherwise sold for pennies. 

And that’s not all. Permutive also has tools for advanced collaboration with advertisers. What if House of Frada wanted to use its own customer seed list with Permutive?

Permutive enables Data Collaboration:

• Frada pushes its CRM buyer list into a Data Clean Room.
• Permutive matches Frada’s list against The Gotham Times’ authenticated readers inside the clean room to create a joint seed.
• Permutive builds a custom lookalike model from that joint seed and deploys it to the edge.
• The model expands Frada’s target audience across The Gotham Times’ vast anonymous reader base.

Thanks to what you already know about DCRs, this should look familiar already. The deterministic side manufactures the ground truth. The probabilistic side spends it. The brand supplies the seed, and the publisher supplies the observation deck. Permutive calls this scenario “predictive data collaboration”.

Note: all these ML models come with a confidence score invariably and someone somewhere must decide where to set the threshold. This is the accuracy-versus-scale dial we illustrated with the Confidence Dial figure earlier. Permutive’s tooling presents publishers with exactly that trade-off, as a curve on which you pick a point.

One last point, about how these cohorts get activated (i.e. how publishers sell them). The resulting cohorts can enter the bid request as publisher-declared segments (with the Gotham Times’ name on the label), but that’s not the only option. The same cohorts can also be packaged across many publishers and offered behind a single Deal ID, through curation partnerships with SSPs. Curation will be the focus of a future installment.

A Quick Note on Contextual Targeting: If you’ve heard of contextual targeting, you might wonder where it fits into this framework. It doesn’t. Contextual targeting is a strategy: match the ad to the content of the page (a luxury handbag banner ad next to a fashion article) and ignore the user entirely (no identity, no history, no memory). What you just saw in Permutive’s feature list is something different: page context used as a feature inside a behavioral model. The page topic is one input among many; the thing being scored is still the browser’s accumulated pattern, not the page. Same signal, two different jobs. Contextual targeting proper is a different animal, and it will get the dedicated treatment it deserves in a future article. For now, just don’t conflate contextual and probabilistic.

Dstillery: modeling from the buyer’s seat

Dstillery attacks the same problem from the opposite end. Here the seed unambiguously belongs to the brand: its customers, its site visitors, its converters. Dstillery builds a custom model for each advertiser. The model learns which browsing patterns tend to precede the behavior that the advertiser cares about. 

Suppose House of Frada wants to find new, high-value luxury shoppers across the web. However, the large majority of web browsing happens without logged-in IDs. Frada cannot use RampIDs or UID2s to reach these people because there are no user tokens attached to their bid requests. This is where Dstillery’s ID-free Custom AI comes into play. 

The Map of the Internet (MOTI)

At the core of Dstillery’s architecture sits a foundation model called MOTI (short for Map of the Internet). MOTI is a neural network trained on massive, continuous sequences of web visitation data by identified users.

Note: for the purposes of this article, a neural network is simply one of the more sophisticated ways to create an ML model.  

Note: you might wonder if this isn’t personal information after all. It is, which is why provenance matters. According to the company, the training data comes from de-identified, opt-in panels, i.e. people who agreed to have their browsing recorded for research, possibly in exchange for an incentive.

MOTI doesn’t just treat URLs as static keywords; it maps how digital journeys flow across millions of websites, page contexts, and times of day. Think of MOTI as a high-resolution, 24-hour GPS map of the open web. Just like Google Maps will know how commuters tend to move from the suburbs to downtown in the morning, and back in the evening, MOTI understands the temporal flow of human browsing—mapping how traffic shifts from morning news readers to afternoon professional research to late-night editorial reading.

Figure: Dstillery’s MOTI is better explained intuitively by comparing it to an analysis of daily GPS traffic. A user on a certain road at a certain time of the day is not unlikely to be headed to a given destination.

Ingesting Frada’s Ground Truth Seed

The process begins when House of Frada wants to launch its new Strada handbag campaign. Frada provides Dstillery with a seed file of its best historical customers, for example, a list of 5,000 normalized, SHA-256 hashed email addresses, one of which belongs to our acquaintance Sloane.

By itself, a static list of email hashes contains no web browsing history. To bridge this gap, Dstillery finds, within its opt-in user database, the consented members who match Frada’s list. The overlap is necessarily small: a panel is a tiny slice of the internet, so perhaps a few hundred of Frada’s 5,000 VIP customers (Sloane among them) appear in it. And here is where the foundation model earns its keep: the Frada model doesn’t need thousands of matched journeys, because MOTI already encodes how browsing flows across the whole web. The seed’s job is only to locate the relevant region of the map, and a few hundred verified pre-purchase journeys are enough for that.

Training the Frada Model and Discarding Sloane’s Data

Dstillery takes the pre-conversion browsing trails of those hundreds matched buyers and plots them as “pins” onto its MOTI map. The neural network analyzes where those customer journeys concentrated on the map in the days and hours leading up to their handbag purchases.

It detects subtle, multi-dimensional correlations that human planners would miss. For instance, the AI discovers that before buying a Strada bag, buyers don’t just read fashion blogs; they heavily visit boutique interior architecture sites on Thursday afternoons, check boutique travel reviews, and browse long-form art commentary on mobile devices during late evening hours.

Once the AI extracts this statistical “Frada signature”, the seed has done its job. What ships is a standalone scoring model; Sloane’s hash is not in it, and nothing about her travels with it. Sloane’s data is never saved as a targetable profile, nor is she tracked across the web. Her email hash was merely training material to identify high-intent “coordinates” on the MOTI map. What remains is a standalone, custom Frada scoring model.

Real-Time Impression Scoring on the Parallel Web

Without logging in, Sloane (or someone acting exactly like her) reads The Gotham Times fashion section on an iPhone 17 Pro in SoHo. There is no UID2 token, no RampID, and no user history attached.

When the anonymous bid request reaches the layer where Dstillery’s model operates (SSP or DSP), it does not ask, “Who is this user?” Instead, it evaluates the environmental telemetry:

• Context & URL: gothamtimes.com/section/fashion
• Temporal Signal: Thursday afternoon
• Environment & Geo: iPhone 17 Pro, iOS 26.5, SoHo, Manhattan (zip 10013)

The model maps these exact telemetry coordinates back to its MOTI scorecard. The model scores this impression 0.89 against the Frada signature.

Dstillery’s model triggers a Curated Deal ID (for ex., DST_FRADA_LOOKALIKE_99), which the exchange attaches to the impression before passing it downstream.

The Shade Desk (Frada’s DSP) reads the Deal ID, recognizes that Dstillery’s model vouches for this specific moment, and submits a winning bid. The ad for the Strada handbag displays on the screen, not because the machinery recognized Sloane Carver, but because it recognized a moment that perfectly matched the statistical footprint of her intent.

On the Effectiveness of Probabilistic Models

At this point, you might be a bit skeptical about the idea that probabilistic models can hold their own against deterministic user identification. After all, a RampID or UID2 guarantees that a certain exact person is in a certain CRM list. How can a statistical guess, however sophisticated, compare to that?

The honest answer is that they compete on different terrain, and the terrain matters more than the accuracy. Think about what happens on the deterministic side. Frada onboards its customer file, the clean room does its matching, and after the match rate takes its cut, the campaign can reach a few thousand identified users. The problem is that every other luxury brand did the same thing. They onboarded similar lists, matched against the same identity graphs, and are now bidding on largely the same pool of authenticated users. Deterministic targeting concentrates the entire demand side onto the small slice of the web where identity exists. Precision is high, but so is the competition, and the price follows the competition.

Now think about the anonymous majority. Most demand-side machinery simply cannot act there: no token, no CRM match, no bid. Traffic shaping makes it worse: under QPS constraints, the pipes prioritize requests that carry identity, so much of the anonymous inventory is never even offered downstream. A model that can score those impressions is not competing against every brand with a customer file. It is competing against the few players equipped to see value where identity is absent. The probabilistic pitch, stripped of vendor enthusiasm, is not “our guesses beat your certainties”. It is “we can show up where your certainties cannot”. Whether the trade nets out depends on the campaign. On one side you have cheaper, less contested inventory; on the other, a lower probability of hitting the right person. Anyone who gives you a universal answer to that dilemma is selling something (a perfectly legitimate activity, let me be completely clear about that).

Note: of course, good marketing will flip it the other way. As a Dstillery presentation memorably put it: “Brand interest isn’t binary… why target like it is?” And they have a point. The Confidence Dial showed that probabilistic modeling forces a trade-off: pick a threshold, accept the false positives or the collapsed reach. If you think about it, the threshold isn’t imposed by the model, which happily produces a continuous score. It’s imposed by activation formats that need a yes or no — a segment, a deal, in or out. Predictive bidding replaces binary in/out membership with continuous pricing: target everyone, pay a price proportional to the score. 

There is a second argument, and it’s about timing rather than territory. Determinism assumes that knowing who someone is tells you what they want. But identity is permanent and intent is not. Consider two scenarios:

1. The deterministic match: Sloane is a verified luxury fashion buyer, and Frada’s clean-room segment says so with confidence 1.00. But right now, at 8:00 AM on a Monday, she is on ESPN checking her fantasy football lineup. The identity is correct. The moment is wrong.
   
2. The impression score: An anonymous user on an iPhone in SoHo opens a long article about 1970s Italian leather craftsmanship at 4:15 PM on a Thursday. The model doesn’t know her name, and never will. But the confluence of signals looks exactly like the moments that preceded a purchase in the seed data: the topic, the time, the place, the device, the reading depth. The identity is missing. The moment is right.

Deterministic targeting knows who; impression scoring bets on when. A complete campaign usually wants both, which is why the two pillars coexist instead of one killing the other.

To be fair to the skeptics, probabilistic scoring is not a silver bullet, and the boundary is easy to state. If you need to reach the person who abandoned Cart #4829 specifically, probability is useless; that is a 1:1 identity problem, and only the deterministic pillar solves it. If you need to find fifty thousand new people who behave like your best customers, the deterministic pillar is structurally too small for the job, and the probabilistic one is the only path to that scale. Retargeting wants certainty. Prospecting wants reach. A lot of the noise in this industry comes from vendors on each side pretending their pillar covers both cases.

Conclusion

If your head is spinning, that’s a reasonable reaction. This article and the previous two covered a lot of ground, and none of it was simple: identity rails, tokens, clean rooms, walled gardens, cohort models, confidence thresholds, seeds and lookalikes. If it’s any consolation, we’ve now met the entire machinery the industry uses to answer its oldest question: “who is worth showing this ad to?” Next time anyone is perplexed about how a machine this infernal can exist, you’ll be the smartest person in the room.

In summary, we have seen three kinds of users in action. The first is the identified user: Sloane logged in, tokens were minted and a clean-room match was confirmed. Frada was ready to bid $22 CPM for that impression. The second is the observed user: parallel-universe Sloane, anonymous but “eyed” — her twelve fashion articles feeding a model that asserts (with 0.81 confidence) what kind of reader she probably is. Deterministic activation serves the first kind; probabilistic modeling serves the second. Each pillar has its own economics, its own trust arrangements, and its own blind spots.

Then there is the third kind, which neither pillar reaches: the stranger. The first-time visitor. The user who cleared their cookies, or whose browser cleared them on their behalf. The CTV session with no login and no trail. No tokens for the deterministic machinery, no behavioral history for cohort modeling. Impression scoring can still take a bet on the moment, but only from whatever signals the request carries. On an anonymous CTV request, those signals are few: the app, the time of day, and whatever the device claims to be. That last part deserves attention, and it will get it later in this series. The industry name for this unreached territory is the addressability gap. 

* Unidentified traffic is roughly 60–70% of the open-web bid stream (observed and stranger combined). Nobody publishes the split between the two, and where the boundary sits depends on whose machinery you ask. 

** Neither as a person. Impression scoring (Dstillery-style) can still act here: it reads only the request itself, and needs neither identity nor history.

Table: the addressability gap — identified, observed and strangers.

BidSwitch, which sits in the middle of hundreds of billions of bid requests a day, reports alternative IDs present in only 35–40% of open-auction traffic; Permutive, a vendor with an obvious interest in the number but a privileged view of it, estimates that ID-based targeting reaches barely 30% of the open web. Whichever figure you prefer, the majority of the bid stream arrives unidentified. Some of the users are observed (and therefore modelable), while the rest are beautiful strangers. That unidentified majority is where other signals will have a role. Those signals are where this series goes next. 

Well, almost next. Before we get there, I’ll need to stop for due diligence. Consent strings, hashed emails, “we never single anyone out” are the foundation on which the entire addressability edifice is built. Believe it or not, that foundation is considerably more fragile than the confident machinery suggests, and my advice is that you become somewhat familiar with the details. That’s the next article.