AdCP vs AAMP: what is the difference?
AdCP and AAMP come from two different organizations and cover overlapping ground. AdCP (Ad Context Protocol) is a single protocol maintained by AgenticAdvertising.org, an independent member organization, and it defines agent tasks such as
get_signals, activate_signal, create_media_buy and build_creative that run over MCP or A2A (AdCP README; AdCP standards landscape). AAMP (Agentic Advertising Management Protocols) is IAB Tech Lab's umbrella initiative, and its repository lists Agentic Direct, a buyer agent, a seller agent, OpenProposal, a registry agent example, ARTF and Agentic Audiences as components (IAB Tech Lab AAMP repo). ARTF runs agent containers inside an exchange during the auction. Agentic Audiences puts embedding vectors into OpenRTB bid requests.AdCP's own documentation describes AAMP as overlapping AdCP in scope "with different primitives" (AdCP standards landscape). This page states what each spec says, as of 2026-10-13, and takes no side.
The four standards side by side (as of 2026-10-13)
| AdCP | AAMP | ARTF | Agentic Audiences | |
|---|---|---|---|---|
| Scope | Agent tasks across the campaign: products, media buys, creative, signals, governance | Umbrella for IAB Tech Lab's agentic work, from planning and RFPs to delivery | Agent services running as containers inside an SSP, DSP or exchange, proposing changes to the bid request | An envelope for passing embeddings (identity, contextual, reinforcement) between agents and in OpenRTB |
| Governing body | AgenticAdvertising.org | IAB Tech Lab (Agentic Task Force) | IAB Tech Lab | IAB Tech Lab (Agentic Audiences Task Force); started as LiveRamp's proposal |
| Transport | MCP or A2A for planning; a Trusted Match HTTP profile for serve time | Buyer and seller agents talk MCP, A2A and REST | gRPC GetMutations and an MCP tool extend_rtb in the reference implementation | OpenRTB community extension at user.data[].segment[].ext.aa |
| Current version and date | 3.2.1, GA on 2026-09-30 | 2.3 released 2026-07-30; 3.0 with OpenProposal announced 2026-09-22, in public comment until 2026-10-22 | 1.0, released 2025-11-12 | 1.1, August 2026 |
| License | Apache 2.0 | Apache 2.0 (AAMP repo and agent SDKs) | Spec CC BY 3.0; Index Exchange reference code AGPL-3.0 | Spec CC BY 4.0; code Apache 2.0 |
| Spec | docs.adcontextprotocol.org | github.com/IABTechLab/AAMP | ARTF spec | OpenRTB extension |
Sources for the table: AdCP version and date from the AdCP release notes, transport from the AdCP README, license from the AdCP repository. AAMP 2.3 from IAB Tech Lab's release of 2026-07-30, AAMP 3.0 from IAB Tech Lab's press release, AAMP transport from the buyer agent README. ARTF from the ARTF repository. Agentic Audiences version from IAB Tech Lab's agentic standards page and license from the agentic-audiences repository.
Which companies are building agentic advertising standards?
AdCP launched on 2025-10-15 with six founding members: Yahoo, Optable, PubMatic, Scope3, Swivel and Triton Digital, with The Weather Company, Magnite, MiQ, LG Ad Solutions, Kargo, Raptive and Samba TV among the supporters named at launch (VideoWeek). AgenticAdvertising.org says it is not a subsidiary or working group of IAB Tech Lab, Anthropic, Google or any other company (AdCP standards landscape).
IAB Tech Lab runs AAMP through its Agentic Task Force (IAB Tech Lab). The ARTF reference implementation is Go code copyrighted by Index Exchange (ARTF repository). The Agentic Audiences extension lists LiveRamp and Raptive as sponsors (OpenRTB extension). The AAMP 2.3 release names contributions and quotes from Amazon Web Services, SafeGuard Privacy, HyperMindz, Mixpeek and Adform (IAB Tech Lab AAMP 2.3 release).
How do I build an AdCP signals agent?
A signals agent implements the AdCP Signals surface. Per the AdCP README, that surface has two tasks:
get_signals discovers audience and contextual signals. A caller searches by natural language or by signal reference, filters by platform and CPM, and gets deployment status with activation keys back (get_signals reference).activate_signal activates a signal on a platform, using the handle that get_signals returned (get_signals reference).You expose those tasks over MCP or A2A; the same task definitions work on both (AdCP standards landscape). The JSON schemas in the AdCP repository are the normative contract, and a compliance runner in the same repository tests agents that claim a protocol (AdCP README). Read the release notes for the version you target: they state that a caller should send the "3.2" wire value only after a peer lists it in
get_adcp_capabilities.The hard part of a contextual signals agent is the signal itself. Each answer to
get_signals has to map a description ("cooking content", "live sports") to inventory you have already classified, so the classification has to exist before the request arrives.How do I build an agent container for IAB Tech Lab's ARTF?
ARTF v1.0 was released on 2025-11-12 (ARTF spec). Your agent ships as a container that the host (an SSP, DSP or exchange) deploys in its own infrastructure, declared by an Agent Manifest. Per the spec and the reference implementation:
tmax, the maximum time in milliseconds the exchange allows for mutations to come back (ARTF spec).intent (for example activateSegments), an op (add, replace or remove), a path that names an OpenRTB business entity rather than a raw JSON location, and a value (ARTF spec). The host decides whether to accept each one.GetMutations, and an MCP tool, extend_rtb (ARTF repository).That last point shapes the design. With no network at bid time, the container cannot call a classification API while the auction waits. Whatever it knows about a page, video or app has to be loaded into the container ahead of time, so the request path is a lookup from a content identifier to stored segments or categories.
How do I generate Agentic Audiences contextual embeddings for OpenRTB?
The OpenRTB community extension defines the envelope. Each provider adds one object to
user.data, and each entry in its segment array carries ext.aa with these fields:ver: the specification version, for example "1.0.0" (extension).vector: the embedding as Float32 values in little-endian byte order, concatenated and Base64-encoded.dimension: the number of Float32 values. A decoder must reject a payload whose decoded byte length divided by 4 does not equal dimension (extension).model: the identifier of the model that produced the vector.type: an integer array where 1 is identity, 2 is contextual and 3 is reinforcement (extension).The extension says nothing about how to produce the vector. IAB Tech Lab describes Agentic Audiences as "the transport layer between counterparties using the same model" and says exchanged signals are usable "as long as the Buyer and Seller are using the same model" (IAB Tech Lab). So the practical steps are: agree on a model with the buyers who will score your vectors, embed the content with it, encode the floats as above, and set
type to contextual. Prebid.js has an Agentic Audiences RTD module that places stored embedding entries under segment.ext.aa (Prebid docs).Our contextual embeddings stopped matching after a model upgrade
That is the expected result. Vectors from two different models live in different spaces, and the extension notes that "similarity computations are meaningful only within the same model/vector space" (extension). IAB Tech Lab's own taxonomy classifier repository warns that comparing vectors from different models, or from different truncations of one model, "still produces a number" and that the number "is meaningless" (iab-taxonomy-classifier).
As of 2026-10-13 the extension defines no re-embedding procedure, deprecation window or migration rule; the
model and ver strings are its only compatibility fields (extension). Implementers decide the rest. Steps that follow from the fields the spec does define:1. Check
model before scoring. A consumer should drop or skip any vector whose model differs from the one its scoring was built on, rather than computing a similarity.
2. Give every model release a new model string. Reusing a name after retraining makes the field useless as a check.
3. Publish both versions during a migration. The extension lets one provider's segment array carry more than one entry (extension), so you can send the old and new vectors side by side until buyers confirm they score the new one.
4. Agree on a cutover date in writing with each counterparty, since the spec sets none.
5. Re-embed stored content from the source files, and keep the old vectors until the cutover passes.
6. Watch match rates per model value after the switch, so a buyer still on the old model shows up as a drop you can explain.Where Mixpeek fits
Mixpeek classifies content at ingest into IAB Content Taxonomy 3.1 IDs, generated from IAB Tech Lab's published taxonomy files, and stores embeddings alongside them, including for video through scene segmentation, frames, speech transcripts and on-screen text. Stored categories and embeddings are the kind of signal a signals agent answering
get_signals or an ARTF container doing a bid-time lookup would read. Mixpeek has no AdCP or ARTF implementation today and runs no hosted AdCP or ARTF endpoint.IAB Tech Lab's AAMP 2.3 release lists a "Content Taxonomy Parser contributed by Mixpeek" (IAB Tech Lab AAMP 2.3 release). The Mixpeek MCP server is listed in IAB Tech Lab's Agent Registry; see every agent in the IAB Tech Lab Agent Registry. To try classification against the taxonomy, use the free IAB contextual classifier demo. To move IDs from Content Taxonomy 2.x to 3.x, see the open-source IAB mapper. For the suitability side, see brand safety vs brand suitability for video.
Changelog
Frequently Asked Questions
Is AdCP part of IAB Tech Lab?
No. AdCP is maintained by AgenticAdvertising.org, which describes itself as an independent member organization and not a subsidiary or working group of IAB Tech Lab (AdCP standards landscape). IAB Tech Lab's own agentic initiative is AAMP.
Is ARTF the same as AAMP?
ARTF is one component of AAMP. The AAMP repository lists ARTF and Agentic Audiences among its components (IAB Tech Lab AAMP repo). ARTF covers agent containers inside an exchange during the auction.
Do AdCP and AAMP both use MCP?
Yes. AdCP tasks run over MCP or A2A (AdCP README), and IAB Tech Lab's buyer agent calls seller agents over MCP, A2A and REST (buyer agent README). The ARTF reference implementation also exposes an MCP tool,
extend_rtb (ARTF repository).Can I comment on AAMP 3.0?
IAB Tech Lab says the OpenProposal specification in AAMP 3.0 is in public comment until October 22, 2026 (IAB Tech Lab). For a field-by-field walkthrough, see OpenProposal (AAMP 3.0) explained.
Which embedding model should I use for Agentic Audiences?
The spec does not name one. It carries whatever model identifier you set, and IAB Tech Lab says the buyer and seller need to use the same model (IAB Tech Lab). Choose with the buyers who will score your vectors. For building a contextual segment from video, see Agentic Audiences contextual embeddings from video.
What intents does ARTF define?
The ARTF protobuf lists eight in its
Intent enum: ACTIVATE_SEGMENTS, ACTIVATE_DEALS, SUPPRESS_DEALS, ADJUST_DEAL_FLOOR, ADJUST_DEAL_MARGIN, BID_SHADE, ADD_METRICS and ADD_CIDS (ARTF protobuf). A container declares the intents it will use in its Agent Manifest, and the spec says a host that cannot support a container's intents should not start it (ARTF spec). A contextual container that adds content categories or segments to the bid request would use ACTIVATE_SEGMENTS or ADD_CIDS.What goes in an ARTF Agent Manifest?
The manifest is JSON attached to the container image as a label. It names the agent, the vendor and an owner email address, and lists the intents, the minimum CPU and memory, and the services the container depends on, by name (ARTF spec). The spec's example stores it Base64-encoded under the label
com.iabtechlab.artf.descriptor, puts the version under com.iabtechlab.artf.container-version, and says to keep secrets out of it. The same example carries liveness and readiness probes and a security block with runAsNonRoot.Does an ARTF container use gRPC or MCP?
gRPC is required. The spec mandates gRPC with protobuf for all interfaces and says MCP may also be used, will likely be required later, and is usable from MCP version 2025-06-18 (ARTF spec). Both expose the same interface. The reference implementation serves gRPC on port 50051 and MCP on 50052, or at
/mcp on the web UI port 8081 when both are enabled (ARTF repository).Will the host apply every mutation my container returns?
The host decides each one. Every mutation is accepted or rejected in whole, and there are no transactions or ordering guarantees across mutations, so a response with three mutations can have one applied and two dropped (ARTF spec). The spec asks hosts to report acceptance rates and rejection reasons. Design each mutation to be useful on its own.
What does a host require before it runs my ARTF container?
The spec's list for any agent touching bidstream data: an OCI container that deploys into Kubernetes, liveness and readiness probes, image signing and verification, images built by a managed and auditable CI/CD pipeline, and OpenTelemetry metrics with OpenTracing traces (ARTF spec). The host sets network policies and resource limits around it.
How do I test an ARTF container locally?
Clone the ARTF repository and run
make generate to build the protobuf code, then make -C examples/golang run-all to start the Go agent with gRPC, MCP and a web UI. make grpc-test (it needs grpcurl) and make mcp-test call the endpoints, and make sample-video or make sample-bidshade send sample OpenRTB requests. Replace the handlers under examples/golang/internal/handlers with your own logic and keep the same service contract. For a worked contextual example in Python, see Build an ARTF agent container that adds IAB content categories.What does an AdCP signals agent have to implement?
Every conformant signals agent implements
get_signals for discovery. activate_signal is required only for an agent that advertises activation, so a discovery-only agent serving its own signals can skip it (AdCP Signals specification). The agent declares Signals support through get_adcp_capabilities with "supported_protocols": ["signals"], supports at least one of MCP or A2A (the spec prefers MCP), and enforces access control on private signals (AdCP Signals specification).What is the difference between a private and a marketplace AdCP signals agent?
A private signal agent is owned by a single account, which has exclusive access to its signals. A marketplace signal agent licenses signal data to multiple accounts (AdCP Signals specification). The SDK's compliance storyboards follow the same split:
signal_owned and signal_marketplace (adcp-client).Is there an SDK for building an AdCP signals agent?
Yes. The JavaScript and TypeScript SDK is
@adcp/sdk (npm install @adcp/sdk). Its repository ships a build-signals-agent skill for coding assistants, aimed at CDPs and data providers: point the assistant at skills/build-signals-agent/SKILL.md and describe your data platform. For a hand-written version, start from examples/signals-agent.ts (adcp-client).How do I test an AdCP signals agent for compliance?
Run the agent locally, then run a storyboard against its MCP endpoint with the SDK, for example
npx @adcp/[email protected] storyboard run http://localhost:3001/mcp signal_owned --json, using signal_marketplace for a marketplace agent. npx @adcp/[email protected] comply <agent> runs the compliance assessment against a saved agent alias (adcp-client).What does get_signals return?
Each signal carries a
signal_agent_segment_id (the handle you pass to activate_signal), a name and description, a signal_type of marketplace, owned or custom, a coverage forecast, pricing_options (a CPM and currency for CPM pricing) and a deployments array. Each deployment says which platform and account it is on and whether it is_live. The activation_key appears only when the signal is live there and the caller has access; when is_live is false, call activate_signal (get_signals reference).