The Layer That Didn't Ship — the donated layer froze, and the job got done twice inside the two runtimes that own a clock THE LAYER THAT DIDN'T SHIP Whoever holds the clock ends up holding the vocabulary. The industry asked for one shared context layer. It exists twice — inside the two runtimes that own a clock. AdCP's serve-time profile, Trusted Match. The clock is written into the spec: each provider gets a timeout_ms defaulting to 50 that has to fit inside the router's latency_budget_ms, and an agent that misses the budget is dropped from the merged response rather than waited for. The surface is marked Experimental and its shapes can change on six weeks' notice. Declared interest: the author co-leads AdCP's Signals and Measurement working group. RUNTIME · OWNS THE CLOCK AdCP · Trusted Match serve-time profile · Experimental The latency budget, drawn as a clock. The ring is the router's latency_budget_ms; the wedge is the slice one provider gets — timeout_ms, default 50. The hand does not stop for a late agent: the merged response goes without it. This is the constraint every other decision about an embedding follows from — dimensions, quantisation, whether you can afford a network hop — which is why the vocabulary ends up living here. timeout_ms defaults to 50 per provider and must fit inside the router's latency_budget_ms. An agent that misses the budget is dropped from the merged response rather than waited for — which is what makes the field shapes a property of this runtime rather than of a document. timeout_ms: 50 default, per provider inside latency_budget_ms miss it and you are dropped AdCP's embedding vocabulary: contextual embeddings carried in context_signals as base64-encoded int8 vectors, alongside embedding_model and embedding_dims. It splits context matching from identity matching and separates the two in time, which is designed to stop them being rejoined. ITS EMBEDDING VOCABULARY context_signals embedding_model embedding_dims base64 int8 vectors The layer everybody agreed was missing. LiveRamp's User Context Protocol — a convention for passing embeddings between agents instead of shipping segment files and hoping both sides had the same taxonomy loaded — was donated to IAB Tech Lab in late 2025, renamed Agentic Audiences by early 2026 and filed under the AAMP umbrella. The dashed border and the crossed-out dial are the whole diagnosis: it was filed somewhere that owns no latency budget. DONATED LAYER · NO CLOCK Agentic Audiences the User Context Protocol, renamed LiveRamp → IAB Tech Lab, late 2025 Read at the repository rather than the press release. IABTechLab/agentic-audiences was created on October 8, 2025 and last pushed to on July 27, 2026. In those ten months it took eleven commits. It has no releases and no tags, two pull requests are open, and its embedding-exchange spec is still headed Draft v0.1. This characterises a repository — not a company's intent, and not a private effort nobody published a record of. 11 COMMITS · 0 RELEASES · 0 TAGS Draft v0.1 · 2 pull requests open last push July 27, 2026 The wire format string in the repo is still vnd.ucp.embedding+json — the retired name sitting inside the media type that implementers would have to code against, more than six months after the rename. It is also the cheapest possible tell: a commit retiring it for a media type carrying the name the spec has had since early 2026 would be the first visible sign this is maintained rather than parked. THE WIRE FORMAT STRING vnd.ucp.embedding+json the retired name, still in the media type a proposal for other people's engineering time AAMP's in-bidstream runtime, ARTF, which reached v1.0 on July 20, 2026 and was pushed to on 4 September. It runs OCI containers inside the host platform's own cluster, speaks gRPC over vendored OpenRTB 2.6 protobuf, and returns atomic bid mutations the host accepts or rejects against a tmax budget. The team that will be blamed when the bid response misses tmax is the team that runs the bidder — and that team will not adopt a format it cannot change. RUNTIME · OWNS THE CLOCK AAMP · ARTF in-bidstream · v1.0, July 20, 2026 The other clock. ARTF's mutations are judged against the host's tmax budget: the host accepts or rejects, and a container that does not answer in time has not answered. Same physics as the other edge, different owner — which is exactly why the two vocabularies never had to agree. ARTF returns atomic bid mutations that the host accepts or rejects, against tmax. gRPC over vendored OpenRTB 2.6 protobuf, in OCI containers inside the host platform's own cluster — the clock, the code and the blame all sit in one place. tmax the host's budget gRPC bid mutations accepted or rejected ARTF's own vocabulary. The shared context layer the industry asked for exists twice, in rival camps, with different field shapes and different rules about what may be carried — which is close to the opposite of what a donation to a neutral standards body was supposed to produce. ITS OWN VOCABULARY different field shapes different rules about what may be carried in the host's own cluster What did ship, and it is worth being exact about how much. The OpenRTB community extension that carries these embeddings rides BidRequest.user.data with an aa envelope at Segment.ext.aa; its nine commits all fall between March 22 and April 13, 2026, and the Prebid.js real-time data module merged on April 14, 2026. A working integration on two of the most widely deployed pieces of plumbing in the industry, delivered in a four-week window, with nothing added since. Narrower than the map promised and still real: a payload convention riding rails somebody else maintains. THE ONE WORKING INTEGRATION · FOUR WEEKS Segment.ext.aa · Prebid.js RTD module March 22 – April 14, 2026 · nothing added since a payload convention on rails somebody else maintains Neither of those two specs references the other's embedding vocabulary. There is no edge to draw here, so none is drawn. The mechanism is not a governance failure, it is a latency budget: an embedding is only worth carrying if it arrives before the auction closes, so every decision about dimensions, quantisation and timeout behaviour is a property of a runtime. If neither camp's serve-time spec has added a reference to the other's embedding fields by the end of 2026, the context layer is settled and the settlement is two vocabularies, permanently. NO REFERENCE, EITHER WAY neither spec references the other's embedding vocabulary A neutral layer donated to a standards body is not the same thing as a layer that ships.
Agentic Advertising

The Layer That Didn't Ship

· 8 min read
The gist

In 2025 the industry agreed it needed a shared layer for exchanging user context between agents. LiveRamp proposed one, donated it to IAB Tech Lab in late 2025, and it was renamed Agentic Audiences by early 2026 and filed under AAMP. Read at the repository rather than the press release, that layer has eleven commits since October 2025, no releases, no tags, two pull requests still open and a spec headed Draft v0.1 — and a wire format string still carrying the retired name. Its one working integration, the OpenRTB community extension on Segment.ext.aa plus the Prebid.js RTD module, shipped inside a four-week window in spring 2026 and has had nothing added since. Meanwhile the job got done twice elsewhere: AdCP carries contextual embeddings in context_signals under a 50ms provider timeout, and AAMP's ARTF mutates bids in-cluster against tmax. Neither references the other's embedding vocabulary. The argument is about how standards actually ship: whoever holds the clock ends up holding the vocabulary, because an embedding is only worth carrying if it arrives before the auction closes, and every design question about it is a property of a latency budget somebody else owns. The tell on any standards effort is commits, tagged releases, and whether its one integration is still maintained.

On this page

The layer everybody agreed was missing

By late 2025 the diagnosis was common property. Agents were going to plan, negotiate and buy at machine speed, and they had no shared way to hand each other meaning. OpenRTB moves the request. AdCOM describes the ad. GPP carries the consent string. None of them answer the question one agent most needs to put to another: what is this moment about, and is this person worth reaching inside it?

LiveRamp proposed an answer. The User Context Protocol was a convention for passing embeddings between agents instead of shipping segment files around and hoping both sides had the same taxonomy loaded. LiveRamp donated it to IAB Tech Lab in late 2025. Tech Lab renamed it Agentic Audiences by early 2026 and filed it under the AAMP umbrella. The map I published in March 2026 called that layer the missing link and built half its argument on it.

In September I went to see what had been built. The answer is not the one the press releases imply, and the reason it turned out that way is the interesting part.

Eleven commits

IABTechLab/agentic-audiences was created on October 8, 2025 and last pushed to on July 27, 2026. In those ten months it took eleven commits. It has no releases and no tags. Two pull requests are open, against a repository whose last push was July 27, 2026. Its embedding-exchange spec is headed “Draft v0.1.” The repository still describes itself as “An open standard by LiveRamp defining how intelligent agents exchange user context, enabling interoperability from prompt-based LLM coordination to embedding-based optimization.” The wire format string in the repo is still vnd.ucp.embedding+json, which is to say the retired name is sitting inside the media type that implementers would have to code against.

Two things that paragraph does not say. It characterises a repository. It does not characterise a company’s intent, and I could find no LiveRamp statement on the work after April 2026, so I am not going to read intent into silence. It also does not say the effort is dead. A lightweight Commit Group was reported at the time as the governance for this work, and I could find no public charter, roster or meeting record for it. Absence of a public record is not evidence that nothing happened in private. Quiet on the public record since that last push is what the evidence supports.

The four weeks that shipped

Something real did get built, and it is worth being exact about how much. The OpenRTB community extension that carries these embeddings, sponsored by LiveRamp and Raptive, rides BidRequest.user.data with an aa envelope at Segment.ext.aa. It has nine commits, every one of them between March 22 and April 13, 2026. The Prebid.js real-time data module merged on April 14, 2026. The repository’s own Prebid folder calls itself a vendor example and points implementers at Prebid.js for the maintained version.

That is a working integration on two of the most widely deployed pieces of plumbing in the industry, delivered inside a four-week window, and nothing has been added to it since. What Agentic Audiences retains today is narrower than the map promised and still real: a payload convention that rides rails somebody else maintains.

The job got done twice, somewhere else

An interest to declare before the next two paragraphs: I co-lead AdCP’s Signals & Measurement working group and run a signals agent in its registry.

AdCP’s serve-time profile, Trusted Match, carries contextual embeddings in context_signals as base64-encoded int8 vectors alongside embedding_model and embedding_dims. It splits context matching from identity matching and separates the two in time, which is designed to stop them being rejoined; the spec states the requirement, and how well any given deployment meets it is a separate question. The clock is written into the spec: each provider gets a timeout_ms defaulting to 50 that has to fit inside the router’s latency_budget_ms, and an agent that misses the budget is dropped from the merged response rather than waited for. The surface is marked Experimental and its shapes can change on six weeks’ notice.

On the other side of the fence, AAMP’s in-bidstream runtime is ARTF, which reached v1.0 on July 20, 2026 and was pushed to on September 4. It runs OCI containers inside the host platform’s own cluster, speaks gRPC over vendored OpenRTB 2.6 protobuf, and returns atomic bid mutations the host accepts or rejects against a tmax budget.

Neither of those two specs references the other’s embedding vocabulary. The shared context layer the industry asked for in 2025 exists twice, in rival camps, with different field shapes and different rules about what may be carried. That is close to the opposite of what a donation to a neutral standards body was supposed to produce, and it is the clearest single illustration of the split I mapped in detail in July.

Why execution migrated to the runtimes

A neutral layer donated to a standards body is not the same thing as a layer that ships, and the gap between them is not a governance failure. It is a physics problem with a commercial shadow.

An embedding is only worth carrying if it arrives before the auction closes. Every design decision that matters about it follows from that constraint: how many dimensions, what quantisation, whether you can afford a network hop to fetch it, what happens to the response when the provider is late. You cannot settle any of those questions in a document that sits outside a runtime, because the answers are properties of a specific latency budget owned by a specific piece of infrastructure. Whoever holds the clock ends up holding the vocabulary, because they are the only party who can tell you whether a proposed field costs three milliseconds or thirty.

There is an incentive layer underneath the physics. The team that will be blamed when the bid response misses tmax is the team that runs the bidder. That team will not adopt a format it cannot change, and it will happily write its own. So the context layer landed where the clocks already were, in AdCP’s serve-time router and in ARTF’s in-cluster containers, and the donated convention stayed where it was filed, on a payload field of rails maintained by somebody else.

This generalises past ad tech. A standards effort with no runtime attached is a proposal for other people’s engineering time, and it will be executed on the schedule of whoever has that time free. A standards effort that ships inside a system with a performance budget gets maintained because the maintainers need it to work on Monday.

What to watch, on any standards effort

The tell is not the announcement, the umbrella it gets filed under or the governance structure named on the day of the donation. It is commits, tagged releases, and whether the one integration that exists is still being maintained. Those three take about ten minutes to check and they disagree with the press release often enough to be worth the ten minutes.

Run the same test on the camp I sit in and it gives a mixed reading rather than a flattering one. AdCP tagged v3.1.21 on September 9 with v3.2.0-rc.1 in prerelease, so the release cadence is real. Its registry holds 35 agents. But a discovery sweep on September 10 found only 9 of them answering a public tools/list: 8 sit behind authentication, 13 return an error, 5 are unreachable. In July the equivalent sweep found 7 discoverable agents out of 21. The roster grew by fourteen and the number of agents a buyer can actually discover grew by two. Read that as commits and releases running ahead of deployed, reachable code, which is a different failure from the one Agentic Audiences has but not a reason to be smug about it.

The map I wrote in March treated one shared context layer as the keystone of the agentic stack. It was the right thing to look for and the wrong place to expect it. Context arrived as a feature of two competing runtimes because that is where an embedding has to land on time to be worth sending at all.

Here is the checkable version. If Agentic Audiences is being maintained rather than parked, the first visible sign will be cheap and specific: a tagged release, or a commit retiring vnd.ucp.embedding+json for a media type carrying the name the spec has had since early 2026. If neither appears by the end of 2026, and neither camp’s serve-time spec has added a reference to the other’s embedding fields by then, the context layer is settled and the settlement is two vocabularies, permanently.

Addendum, September 16, 2026 — two things in this essay need adding to, and the second is a miss of mine.

The repository moved, slightly. On September 15 a collaborator was added to IABTechLab/agentic-audiences, and half an hour later that collaborator closed pull request #17, a documentation link to the OpenRTB extension, noting that the link was already on the main branch. That leaves one open pull request, #11, with no activity since April 13. Closing #17 was the first maintainer action on any pull request or issue since the July 27 push, and it reads as tidying rather than shipping: there is still no commit since July 27, no release and no tag, and the wire format string still reads vnd.ucp.embedding+json. Neither of the two signs this essay closes on has appeared.

The governance point needs adding to. I wrote that I could find no public charter, roster or meeting record for the Commit Group reported as this work’s governance, and that still holds for the Commit Group. But on August 4, five weeks before this essay, IAB Tech Lab’s chief executive Anthony Katsur published a post saying the work to date had been driven by the Tech Lab Agentic Task Force, and announcing a separate Agentic Audiences Task Force with sign-up through Tech Lab’s membership team. I should have found it. It also means the public record was not quiet after the July 27 push, as I wrote; the repository was. The same post credits an OpenRTB community extension and a Prebid module update with making the data exchange “interoperable, but also transaction-ready”, which is the integration this essay identifies as the part that shipped. The post also names an open-source scorer, which this essay did not discuss; it lives in the same repository, and the July 27 commit was a fix to it.

Ad · served by our AdCP stack