Agentic Audience Intelligence.

Bring a dataset and leave with an audience: the engine assesses the data, recommends a method and a model, and builds the audience at the reach you set. Before any of that runs, it answers the question every clean-room lawyer and data owner asks first: is this data allowed to do this specific thing, here, for this destination? It answers per method, with the evidence, before any score exists.

Agents read the source profile and propose what could be built: a seed-affinity look-alike, a behavioral-affinity act-alike, an aggregate report, a contextual cohort, or a registered model of your own. A deterministic router checks each proposal against policies, unit mappings, model registrations and thresholds, and returns a verdict with reasons. Only then does modeling run, and only where the verdict allows.

The modeling is machine learning, run by the engine rather than by the agents: k-means multi-prototype and centroid similarity for look-alikes, logistic-regression and gradient-boosted propensity models for outcomes, with fixed seeds and reported metrics. Agents choose what to propose; they never train or tune a model, so nothing an agent says becomes a fact nobody can audit.

The demonstrator’s workbench runs the real engine over eight generated datasets: the router decides every method, the eligible models are trained and compared on held-out records, and the results ship as static bundles. Nothing runs while you browse; the page filters what was computed, and each bundle carries the engine and snapshot hashes that produced it. Uploads and live runs come with a server version of the same engine.

In the interface, a look-alike is seed affinity: how close an entity sits to a seed set. An act-alike is behavioral affinity: how closely its behavior matches a pattern. Neither is presented as a probability. Only a calibrated propensity model can say “estimated chance of [event] by [horizon]”. Training one is itself a task the router gates, and it stays provisional until the calibration evidence exists.

A model you bring is registered, not trusted. Its registration declares what it needs and where it may run, and the router checks those declarations like any other evidence. Remote inference is its own operation, so sending features to a model outside the data owner’s walls needs its own permission.

Recommendations rank only the options that are eligible against the same objective. The requested task always stays visible, a ranking cannot override a verdict, and when costs are unknown the ranker says it cannot rank rather than guessing.

This is a working engine, not a validated product. What has been checked is listed here, and so is what has not. In the demonstrator’s look-alike run, multi-prototype scoring finds more held-out seeds than a single centroid. That is a synthetic result: it shows the software behaves as designed, not that it would beat anything on real data.

Agentic advertising is standardizing how audiences travel between agents: IAB Tech Lab’s Agentic Audiences passes them as embeddings, and AdCP carries signals and activation between buyer and seller agents. Neither tells a data owner what their data is permitted to become. This engine is that missing step, upstream of the exchange: it decides what may be built, and its AdCP adapter builds signals only from release manifests, after people have approved them.

It sits beside the AdCP Signals Adaptor, which serves signals to buyer agents, and the AdCP Publisher Stack, which sells against them. This build is the part that decides, with reasons, which audiences should exist at all.