AAMP (Agentic Advertising Management Protocols)

Last updated: March 16, 2026

Large language models, transformer architectures, and breakthroughs in GPU compute are fundamentally changing how we connect advertisers with audiences through autonomous or semi-autonomous agents that facilitate media discovery, planning, buying, and other functions.

IAB Tech Lab’s Agentic roadmap to provide Standards for Agentic Advertising, powered by the same proven Standards that power the ecosystem today has been brought together under a single initiative – AAMP – the Agentic Advertising Management Protocols.

AAMP is the umbrella initiative under which all of Tech Lab’s Agentic work is being developed in partnership with the advertising ecosystem.

AAMP has a defined roadmap, which is being executed as an open-source project with the Agentic Task Force at IAB Tech Lab weighing in on requirements. And it encompasses far more than a single framework.

AAMP is built on three pillars.

Agentic Foundations
Agentic Protocols
Trust and Transparency

You can find details on all what each of these is below.

Jump to sections

AAMP Pillars

Protocols & Use Cases

Reference Implementation

AAMP GitHub Repos

What is AAMP?

This short explainer video outlines our approach to Agentic Advertising and reviews the 3 pillars of the AAMP (Agentic Advertising Management Protocols) framework – Foundations, Protocols, and Trust and Transparency.

IAB Tech Lab's Approach to Agentic

The key agentic protocols – MCP from Anthropic, and Google’s Agent to Agent – perform best when they have utility schemas along with reference implementations to establish context. In fact, they thrive on Standardized Schemas, Standards are needed for referenceable context, so the agents are trained to execute the action asked in a natural language with repeatable accuracy.

That is why IAB Tech Lab’s approach to the agentic advertising future, as outlined by our CEO, Anthony Katsur starts with existing industry standards. It’s not because we’re resistant to change, but because these standards represent compressed industry knowledge refined through billions of transactions.

The Three Pillars of AAMP

AAMP is built across 3 pillars, which are deliberately complementary. Certain agentic tasks do not scale without a high-performance execution infrastructure. Execution infrastructure is meaningless without shared standards. And the ecosystem needs a neutral party providing agent transparency. All are required if you want agentic systems that operate at scale without ambiguity, hallucination, or erosion of trust.

Agent Foundations

The first pillar is high-performance delivery, execution, and control.

This is where ARTF lives. ARTF defines how agent services can safely and deterministically operate inside advertising systems, including real-time bidding environments, cutting latency by 80% and upleveling real time decisioning for quality and trust. It is about execution. It is about performance. It is about making outputs of agentic systems viable in production via it’s MCP interface built into the specification.

Agentic Protocols

The Agentic Protocols pillar, provides schemas, tools, and reference implementations for integrating Agentic AI technology into buyer, seller, and adtech provider systems.

This is the management layer. It defines how buyer and seller agents understand each other, discover, negotiate, transact orders and deals, exchange signals, and complete laborious and cumbersome setup tasks required before execution. This includes work like Agentic Direct, Agentic Audiences, formerly the LiveRamp UCP donation, Agentic Mobile, and Agentic Ad Object (derived from AdCOM), along with buyer and seller reference agents.

Trust and Transparency

The third pillar is trust: the Agent Registry, which is part of the Tools Portal, which is open to members, and non-members, and is free for anyone to sign up and register.

This pillar provides neutral agent transparency and accountability across the ecosystem. It establishes a trusted framework for agent identity, verification, and disclosure so participants can confidently understand who (or what) they are transacting with

AAMP Agentic Protocols & Use Cases

There are two layers to Agentic Protocols. The first is the open source software layer, where we are developing SDKs in our GitHub, starting with Agentic Direct and Buyer and Seller Agents.

The second layer is the collection of Object Models and Primitives which ensure the Agents stay on track. These are based on existing Taxonomies. including the Privacy Taxonomy, and Tech Lab Standards such as the Deals API and AdCOM.

The already-released Agentic Direct SDK uses the OpenDirect standard as a Primitive.

Watch AAMP in action!

In the webinar where we launched the Agentic Roadmap, now reframed as AAMP, COO Shailley Singh demoed using the Tech Lab reference implementations to create a Media Plan based on a brief, negotiate with the seller, and then confirm the transaction and push it to Google Ad Manager (GAM). We have added that excerpt here.

This demo uses Agentic Technology in parallel with Tech Lab Standards including OpenDirect, AdCOM, and the Content, Ad Product, and Audience Taxonomies.

Access the GitHub repositories and you can experiment with replicating this Agentic use case today.

Open Source Reference Schemas

We have created open source reference schemas and an agentic integration of the OpenDirect specification and the new Deals API , built on principles established in the Agentic Real Time Framework (ARTF), that you can find in the GitHub links below.

Agent Discovery and Negotiation

As Buyer Agents look to discover the inventory that matches their campaign objectives, they will need to communicate with Seller Agents using a common language, that of standard taxonomies – Content, Audience, and Privacy, and the AdCOM object model used by OpenRTB.

Agentic Direct Transactions

For direct transactions, the OpenDirect specification enables automated buying and selling and integration with key Publisher Ad Servers. Our reference Agentic Direct implementation uses this today, and the OpenDirect specification can be updated as use cases arise.

Transacting with Agentic Deals

Should programmatic channels, such as PMPs, be preferred for the transactions, the new Deals API enables agents to communicate deals with the SSP and DSP. Those Deals can be enriched using the ARTF standard, or by the SSPs and DSPs directly.

Agentic Open Bidding

The same framework can also support open bidding as the same object models are referenced by OpenRTB. In this case the buying and selling agents would communicate with their SSP and DSP partners, who can use the ARTF specification to enrich their bids.

Buyer and Seller Agent SDKs

The Agentic ecosystem will start with a Buyer Agent and Seller Agent taking to each other. To help companies get started with this, we have included open-source reference implementation for Ad Buyer Systems and Ad Seller Systems.

You can download the Buyer Agent SDK and the Seller Agent SDK in our GitHub repository.